Coralite Type Reference

  /**
  * @callback CoraliteOnError
  * @param {CoraliteErrorData} data - The error or warning data.
  * @returns {void}
  */

  /**
        * @callback CoraliteModuleScript
        * @param {CoraliteProperties} properties - The module's current properties
        * @param {CoraliteRef} refs - References template elements
        */

  /**
        * @callback CoraliteCollectionEventSet
        * @param {CoraliteCollectionItem} value - Item to be set
        * @returns {Promise<coralitecollectioneventresult>} Returns a result object with processed value and optional ID
          * @async
          */</coralitecollectioneventresult>

  /**
        * @callback CoraliteCollectionEventDelete
        * @param {CoraliteCollectionItem} value - Item or pathname to delete
        * @async
        */

  /**
        * @callback CoraliteCollectionEventUpdate
        * @param {CoraliteCollectionItem} newValue - New item value
        * @param {CoraliteCollectionItem} oldValue - Original item value
        * @async
        */

  /**
        * @template T
        * @this {ThisType<coralite>}
          * @callback CoralitePluginModule
          * @param {T} options - Configuration options passed to the plugin
          * @param {CoralitePluginContext} context - Runtime context providing access to properties, document data, module
          info, and path details
          */</coralite>

  /**
        * @this {ThisType<coralite>}
          * @callback CoralitePluginPageSetCallback
          * @description Async callback triggered when a page is created. Called with elements, properties, and data.
          * @param {Object} param
          * @param {ParseHTMLResult} param.elements - Parsed HTML elements from the page
          * @param {CoraliteFilePath &amp; Object.&amp;lt;string, any&gt;} param.properties - Properties associated with the page path
          * @param {CoraliteCollectionItem} param.data - Data item representing the newly created page
          * @async
          */</coralite>

  /**
        * @this {ThisType<coralite>}
          * @callback CoralitePluginPageUpdateCallback
          * @description Async callback triggered when a page is updated. Called with elements, new and old properties.
          * @param {Object} param
          * @param {CoraliteElement[]} param.elements - Updated HTML elements from the page
          * @param {CoraliteCollectionItem} param.newValue - The updated data item
          * @param {CoraliteCollectionItem} param.oldValue - The previous data item before update
          * @async
          */</coralite>

  /**
        * @this {ThisType<coralite>}
          * @callback CoralitePluginPageDeleteCallback
          * @description Async callback triggered when a page is deleted. Called with the deleted data.
          * @param {CoraliteCollectionItem} value - The data item being deleted
          * @async
          */</coralite>

  /**
        * @this {ThisType<coralite>}
          * @callback CoralitePluginComponentCallback
          * @description Async callback triggered for component-related events (set, update, delete).
          * @param {CoraliteModule} component - The component module that was set, updated, or deleted
          * @async
          */</coralite>

  /**
        * @this {ThisType<coralite>}
          * @callback CoralitePluginBeforePageRenderCallback
          * @param {Object} param
          * @param {CoraliteComponent} param.component - The page component being rendered
          * @param {Object} param.properties - The current properties context
          * @param {CoralitePage} param.page - The page metadata object
          * @param {Object} param.renderContext - The build&apos;s render context
          * @async
          */</coralite>

  /**
        * @this {ThisType<coralite>}
          * @callback CoralitePluginAfterPageRenderCallback
          * @param {CoraliteResult} result - The rendered page result
          * @returns {CoraliteResult | CoraliteResult[] | void} Additional pages to add to the build
          * @async
          */</coralite>

  /**
  * @constructor
  * @param {Object} options
  * @param {string} options.components - The path to the directory containing Coralite components.
  * @param {string} options.pages - The path to the directory containing pages.
  * @param {CoralitePluginInstance[]} [options.plugins=[]]
  * @param {CoraliteStaticAsset[]} [options.assets=[]]
  * @param {IgnoreByAttribute[]} [options.ignoreByAttribute]
  * @param {string[]} [options.skipRenderByAttribute]
  * @param {CoraliteOnError} [options.onError]
  * @param {'production' | 'development'} [options.mode='production']
  * @param {string} [options.output]
  */

  /**
      * Initialises the Coralite instance.
      * @returns {Promise<void>}
          */
          Coralite.prototype.initialise = async function () {
          }
  </void>

  /**
      * @param {string | string[]} [path] - Optional page path(s) to build
      * @param {Object} [options] - Build configuration
      * @param {BuildPageHandler} [callback] - Transformation callback
      * @return {Promise<array<any>&gt;}
          */
          Coralite.prototype.build = async function (path, options, callback) {
          }
  </array<any>

  /**
      * Compiles and saves pages to disk.
      * @param {string | string[]} [path] - Optional page path(s) to build
      * @param {Object} [options] - Save configuration
      * @returns {Promise<array<{ path: string, duration: number }>&gt;}
          */
          Coralite.prototype.save = async function (path, options) {
          }
  </array<{>

  /**
  * Renders the provided node or array of nodes using the render function.
  * @param {CoraliteComponentRoot | CoraliteAnyNode | CoraliteAnyNode[]} root - The node(s) to be rendered.
  * @returns {string} returns raw HTML
  */
  Coralite.prototype.transform = function (root) {
  }

  /**
  * Retrieves page paths associated with a custom element component.
  *
  * @param {string} path - The original path potentially prefixed with the components directory.
  * @returns {string[]} An array of page paths linked to the custom element component.
  */
  Coralite.prototype.getPagePathsUsingCustomElement = function (path) {
  }

  /**
  * Adds a page to the current render queue.
  * @param {string|CoraliteCollectionItem} value - The path to a page or a CoraliteCollectionItem to add to
  the render queue.
  * @param {string} buildId - The unique identifier for the current build process.
  */
  Coralite.prototype.addRenderQueue = async function (value, buildId) {
  }

  /**
     * @param {Object} options
     * @param {string} options.id - Unique identifier for the component
     * @param {CoraliteModuleDefinitions} [options.properties={}] - Token properties available for replacement
     * @param {CoraliteElement} [options.element] - The target custom element
     * @param {CoraliteComponent} options.component - Current document being processed
     * @param {string} [options.contextId] - Context Id
     * @param {number} [options.index] - Context index
     * @param {Object} [options.renderContext] - The build's render context
     * @returns {Promise<coraliteelement | void>}
     */
    Coralite.prototype.createComponentElement = async function (options, head = true) {
    }
  </coraliteelement>

  /**
      * Parses a Coralite module script and evaluates it.
      * @private
      * @param {Object} data
      * @param {CoraliteModule} data.module - The Coralite module to evaluate
      * @param {CoraliteModuleDefinitions} data.properties - Replacement properties for the component
      * @param {CoralitePage} data.page - The global page object
      * @param {CoraliteElement} data.root - The component's root element
      * @param {CoraliteComponent} data.component - The document context
      * @param {string} data.contextId - Context Id
      * @param {Object} data.renderContext - The build's render context
      *
      * @returns {Promise<coralitemoduledefinitions>}
          */
          Coralite.prototype._evaluate = async function (data) {
          }
  </coralitemoduledefinitions>

  /**
  * @param {CoraliteFilePath} path
  * @param {Object} context
  * @private
  */
  Coralite.prototype._moduleLinker = function (path, context) {
  }

  /**
      * @template T
      * @private
      * @param {string} name - The name of the hook to trigger.
      * @param {T} initialData - Data to pass to each callback function.
      * @return {Promise<t>} A promise that resolves to the merged data.
          */
          Coralite.prototype._triggerPluginHook = async function (name, initialData) {
          }
  </t>