coralite 0.37.1 → 0.37.2

package/dist/lib/utils/core.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../lib/utils/errors.js", "../../../lib/utils/core.js"],
+  "sourcesContent": ["\n/**\n * @import { CoraliteErrorData } from '../../types/index.js'\n */\n\n/**\n * Base error class for all Coralite-related errors.\n */\nexport class CoraliteError extends Error {\n  /**\n   * @param {string} message - The error message.\n   * @param {Object} [options] - Additional options for the error.\n   * @param {string} [options.componentId] - The ID of the component where the error occurred.\n   * @param {string} [options.filePath] - The path to the file where the error occurred.\n   * @param {string} [options.instanceId] - The unique ID of the component instance.\n   * @param {string} [options.pagePath] - The path to the page being rendered.\n   * @param {number} [options.line] - The line number where the error occurred.\n   * @param {number} [options.column] - The column number where the error occurred.\n   * @param {string} [options.stackFile] - The file name from the stack trace.\n   * @param {Error} [options.cause] - The original error that caused this error.\n   */\n  constructor (message, options = {}) {\n    super(message, options)\n    this.name = 'CoraliteError'\n    this.isCoraliteError = true\n    this.componentId = options.componentId\n    this.filePath = options.filePath\n    this.instanceId = options.instanceId\n    this.pagePath = options.pagePath\n    this.line = options.line\n    this.column = options.column\n    this.stackFile = options.stackFile\n\n    // Polyfill cause if necessary (node version differences)\n    if (options.cause && !this.cause) {\n      this.cause = options.cause\n    }\n  }\n}\n\n/**\n * Default error handler.\n * @param {CoraliteErrorData} data - The data object containing error details.\n */\nexport function defaultOnError ({ level, message, error }) {\n  if (level === 'ERR') {\n    if (error) {\n      throw error\n    }\n    throw new CoraliteError(message)\n  } else if (level === 'WARN') {\n    console.warn(message)\n  } else {\n    console.log(message)\n  }\n}\n\n/**\n * Handles errors using an optional callback or the default handler.\n * @param {Object} options - The options for handling the error.\n * @param {Function} [options.onErrorCallback] - The optional custom error callback function.\n * @param {CoraliteErrorData} options.data - The error data to be handled.\n */\nexport function handleError ({ onErrorCallback, data }) {\n  const error = data.error\n  if (error && 'isCoraliteError' in error && error.isCoraliteError) {\n    const coraliteError = error\n    // @ts-ignore\n    data.componentId = data.componentId || coraliteError.componentId\n    // @ts-ignore\n    data.filePath = data.filePath || coraliteError.filePath\n    // @ts-ignore\n    data.instanceId = data.instanceId || coraliteError.instanceId\n    // @ts-ignore\n    data.pagePath = data.pagePath || coraliteError.pagePath\n    // @ts-ignore\n    data.line = data.line || coraliteError.line\n    // @ts-ignore\n    data.column = data.column || coraliteError.column\n    // @ts-ignore\n    data.stackFile = data.stackFile || coraliteError.stackFile\n  }\n\n  if (onErrorCallback) {\n    onErrorCallback(data)\n  } else {\n    defaultOnError(data)\n  }\n}\n", "import { CoraliteError } from './errors.js'\n\n/**\n * @import {\n * CoraliteModule,\n * CoraliteComponent,\n * CoraliteComponentResult,\n * } from '../../types/index.js'\n */\n\nconst KEBAB_REGEX = /[-|:]([a-z])/g\n\n/**\n * Converts a kebab-case string to camelCase\n * @param {string} str - The kebab-case string to convert\n * @returns {string} - The camelCase version of the string\n */\nexport function kebabToCamel (str) {\n  // replace each dash followed by a letter with the uppercase version of the letter\n  return str.replace(KEBAB_REGEX, function (match, letter) {\n    return letter.toUpperCase()\n  })\n}\n\n/**\n * Converts all keys in an object from kebab-case to camelCase\n * @template T\n * @param {Record<string, T>} object - The object with kebab-case keys\n * @returns {Record<string, T>} - A new object with camelCase keys\n */\nexport function cleanKeys (object) {\n  /** @type {Record<string, T>} */\n  const result = {}\n\n  for (const [key, value] of Object.entries(object)) {\n    result[key] = value\n\n    const camelKey = kebabToCamel(key)\n    if (camelKey !== key) {\n      result[camelKey] = value\n    }\n  }\n\n  return result\n}\n\n/**\n * Recursively clones an object or array and normalizes any function state\n * it finds into a string representation that preserves standard function syntax,\n * bypassing ES6 shorthand method serialization issues.\n * @param {any} target - The object or array to normalize.\n * @param {Function} [transform] - Optional transform function for each node.\n * @param {WeakMap} [seen=new WeakMap()] - Map of seen objects to handle circular references.\n * @returns {any} A deeply cloned object with normalized functions.\n */\nexport function normalizeObjectFunctions (target, transform = null, seen = new WeakMap()) {\n  if (typeof transform === 'function') {\n    const transformed = transform(target)\n    if (transformed !== target) {\n      return transformed\n    }\n  }\n\n  if (typeof target !== 'object' || target === null) {\n    return target\n  }\n\n  if (seen.has(target)) {\n    return seen.get(target)\n  }\n\n  if (Array.isArray(target)) {\n    const arr = []\n    seen.set(target, arr)\n    for (let i = 0; i < target.length; i++) {\n      arr.push(normalizeObjectFunctions(target[i], transform, seen))\n    }\n    return arr\n  }\n\n  const obj = {}\n  seen.set(target, obj)\n  for (const key in target) {\n    if (Object.hasOwn(target, key)) {\n      if (typeof target[key] === 'function') {\n        const normalizedString = normalizeFunction(target[key])\n        const originalFunction = target[key]\n\n        const wrapper = function () {\n          return originalFunction.apply(this, arguments)\n        }\n        wrapper.toString = () => normalizedString\n        obj[key] = wrapper\n      } else {\n        obj[key] = normalizeObjectFunctions(target[key], transform, seen)\n      }\n    }\n  }\n\n  return obj\n}\n\n/**\n * Checks whether the given object is an object and has at least one own key.\n * @param {any} obj - The object to check.\n * @returns {boolean} True if the object is truthy and has keys, otherwise false.\n */\nexport function hasObjectKeys (obj) {\n  return obj && typeof obj === 'object' && Object.keys(obj).length > 0\n}\n\n/**\n * Merges two arrays, returning a new array with unique items.\n * Uses JSON.stringify for deep comparison of object elements, preserving object uniqueness correctly.\n * @param {Array<any>} [arr1] - The first array.\n * @param {Array<any>} [arr2] - The second array.\n * @returns {Array<any>} A new array with unique values from both input arrays.\n */\nexport function mergeUniqueObjects (arr1, arr2) {\n  const all = [...(arr1 || []), ...(arr2 || [])]\n  const seen = new Set()\n  return all.filter(item => {\n    const key = typeof item === 'object' ? JSON.stringify(item) : item\n    if (seen.has(key)) {\n      return false\n    }\n    seen.add(key)\n    return true\n  })\n}\n\n/**\n * Normalizes function declarations to ensure consistent formatting.\n * Converts shorthand method syntax to full function declarations where needed,\n * while preserving arrow functions and existing full declarations.\n *\n * @param {Function} func - The function to normalize\n * @returns {string} The normalized function string representation\n */\nexport function normalizeFunction (func) {\n  const original = func.toString().trim()\n\n  const firstBrace = original.indexOf('{')\n  const firstArrow = original.indexOf('=>')\n\n  const isArrow = firstArrow !== -1 && (firstBrace === -1 || firstArrow < firstBrace)\n\n  if (isArrow) {\n    return original\n  }\n\n  // For non-arrows, extract header to check for shorthand\n  const header = firstBrace !== -1 ? original.slice(0, firstBrace).trim() : original\n\n  const isStandard = header.startsWith('function') || header.startsWith('async function')\n\n  if (isStandard) {\n    return original\n  }\n\n  // Handle Method Shorthand\n  if (header.startsWith('async ')) {\n    if (header.startsWith('async get ') || header.startsWith('async set ')) {\n      return original\n    }\n\n    return original.replace(/^async\\s+([$\\w]+)\\s*\\(/, 'async function(')\n  } else {\n    if (header.startsWith('get ') || header.startsWith('set ')) {\n      return original\n    }\n\n    return original.replace(/^([$\\w]+)\\s*\\(/, 'function(')\n  }\n}\n\n\n/**\n * Recursively clones an AST node and its children, ensuring that\n * inner references (like parents and slots) point to the newly cloned nodes.\n *\n * @param {Map<Object, Object>} nodeMap - A map tracking original nodes to their newly cloned counterparts.\n * @param {Object} node - The current AST node being cloned.\n * @param {Object} [parent] - The parent node reference to assign to the clone.\n * @returns {Object} The newly cloned node.\n */\nexport function cloneNode (nodeMap, node, parent) {\n  const newNode = Object.create(Object.getPrototypeOf(node))\n\n  // Copy all own enumerable properties\n  Object.assign(newNode, node)\n\n  if (parent) {\n    newNode.parent = parent\n  }\n\n  if (newNode.attribs) {\n    newNode.attribs = { ...newNode.attribs }\n  }\n\n  // Register in map\n  nodeMap.set(node, newNode)\n\n  // Recursively clone children\n  if (node.children) {\n    const children = node.children\n    const length = children.length\n    const clonedChildren = new Array(length)\n    newNode.children = clonedChildren\n\n    for (let i = 0; i < length; i++) {\n      const clonedChild = cloneNode(nodeMap, children[i], newNode)\n      clonedChildren[i] = clonedChild\n      if (i > 0) {\n        clonedChild.prev = clonedChildren[i - 1]\n        clonedChildren[i - 1].next = clonedChild\n      }\n    }\n  }\n\n  // Update slot references to point to new cloned nodes\n  if (node.slots) {\n    const slots = node.slots\n    const length = slots.length\n    const clonedSlots = new Array(length)\n    for (let i = 0; i < length; i++) {\n      const slot = slots[i]\n      const clonedSlot = { ...slot }\n      if (slot.node) {\n        const clonedNode = nodeMap.get(slot.node)\n        if (clonedNode) {\n          clonedSlot.node = clonedNode\n        }\n      }\n      clonedSlots[i] = clonedSlot\n    }\n    newNode.slots = clonedSlots\n  }\n\n  // Preserve the enhanced flag without re-running enhanceNode\n  Object.defineProperty(newNode, '__coralite_enhanced__', {\n    value: true,\n    enumerable: false,\n    configurable: true\n  })\n\n  return newNode\n}\n\n/**\n * Creates a shallow copy of a CoraliteModule with a deep clone of its DOM tree (template) and re-linked internal references to enable safe independent mutation.\n *\n * Top-level non-DOM state (id, path, script, isTemplate, lineOffset) are shallow copied. Nested objects within these state (e.g., path) remain shared references. Only DOM-related structures undergo deep cloning and reference re-linking to isolate mutations from the original module.\n *\n * @param {CoraliteModule} originalModule - Module to clone.\n * @returns {CoraliteModule}\n */\nexport function cloneModuleInstance (originalModule) {\n  const nodeMap = new Map()\n\n  // Clone the main template tree\n  const newTemplate = cloneNode(nodeMap, originalModule.template, null)\n\n  // Reconstruct the 'values' object\n  const newValues = {\n    attributes: originalModule.values.attributes.map(item => ({\n      ...item,\n      element: nodeMap.get(item.element)\n    })),\n    textNodes: originalModule.values.textNodes.map(item => ({\n      ...item,\n      textNode: nodeMap.get(item.textNode)\n    })),\n    refs: originalModule.values.refs.map(item => ({\n      ...item,\n      element: nodeMap.get(item.element)\n    }))\n  }\n\n  // Reconstruct customElements list\n  const newCustomElements = originalModule.customElements.map(el => nodeMap.get(el))\n\n  // Reconstruct slotElements\n  const newSlotElements = {}\n  if (originalModule.slotElements) {\n    for (const modId in originalModule.slotElements) {\n      newSlotElements[modId] = {}\n      const slotGroup = originalModule.slotElements[modId]\n\n      for (const slotName in slotGroup) {\n        const slotItem = slotGroup[slotName]\n        newSlotElements[modId][slotName] = {\n          ...slotItem,\n          element: nodeMap.get(slotItem.element)\n        }\n      }\n    }\n  }\n\n  // Return the new module structure\n  return {\n    ...originalModule,\n    template: newTemplate,\n    values: newValues,\n    customElements: newCustomElements,\n    // @ts-ignore\n    slotElements: newSlotElements\n  }\n}\n\n/**\n * Creates a deep copy of a CoraliteComponent with re-linked internal references to enable safe independent mutation.\n *\n * @param {CoraliteComponent & CoraliteComponentResult} originalDocument - Document to clone.\n * @returns {CoraliteComponent & CoraliteComponentResult}\n */\nexport function cloneComponentInstance (originalDocument) {\n  const nodeMap = new Map()\n  const newRoot = cloneNode(nodeMap, originalDocument.root, null)\n\n  const newCustomElements = originalDocument.customElements.map(el => nodeMap.get(el))\n  const newTempElements = originalDocument.tempElements ? originalDocument.tempElements.map(el => nodeMap.get(el)) : []\n  const newSkipRenderElements = originalDocument.skipRenderElements ? originalDocument.skipRenderElements.map(el => nodeMap.get(el)) : []\n\n  return {\n    ...originalDocument,\n    state: { ...originalDocument.state },\n    root: newRoot,\n    customElements: newCustomElements,\n    tempElements: newTempElements,\n    skipRenderElements: newSkipRenderElements\n  }\n}\n\n/**\n * Calculates the DOM path from a node to the root.\n * @param {Object} node - The node to calculate the path for.\n * @param {Object} root - The root node.\n * @returns {Array<number>} An array of indices representing the path.\n */\nexport function getNodePath (node, root) {\n  const path = []\n  let current = node\n  while (current && current !== root) {\n    const parent = current.parent\n    if (!parent) {\n      break\n    }\n    const index = parent.children.indexOf(current)\n    if (index === -1) {\n      break\n    }\n    path.unshift(index)\n    current = parent\n  }\n  return path\n}\n\n/**\n * Generates a hydration map for the client.\n * @param {Array<Object>} templateNodes - The component's template nodes.\n * @param {Object} templateValues - The component's template values.\n * @returns {Object} The hydration map.\n */\nexport function generateHydrationMap (templateNodes, templateValues) {\n  const map = {\n    texts: [],\n    attributes: [],\n    refs: []\n  }\n\n  if (!templateNodes || !templateValues) {\n    return map\n  }\n\n  const root = templateNodes.length > 0 ? templateNodes[0].parent : { children: templateNodes }\n\n  if (templateValues.textNodes) {\n    for (const item of templateValues.textNodes) {\n      if (item.textNode) {\n        const isHtml = item.type === 'html'\n        const targetNode = isHtml ? item.textNode.parent : item.textNode\n\n        map.texts.push({\n          path: getNodePath(targetNode, root),\n          template: item.textNode.data,\n          type: isHtml ? 'html' : 'text'\n        })\n      }\n    }\n  }\n\n  if (templateValues.attributes) {\n    for (const item of templateValues.attributes) {\n      if (item.element && item.element.attribs) {\n        const originalValue = item.element.attribs[item.name]\n        map.attributes.push({\n          path: getNodePath(item.element, root),\n          name: item.name,\n          template: originalValue\n        })\n      }\n    }\n  }\n\n  if (templateValues.refs) {\n    for (const item of templateValues.refs) {\n      if (item.element) {\n        map.refs.push({\n          path: getNodePath(item.element, root),\n          name: item.name\n        })\n      }\n    }\n  }\n\n  return map\n}\n\n/**\n * Recursively adds a component and its dependencies to a tracking object.\n *\n * @param {string} componentId - The ID of the component to add.\n * @param {Object.<string, boolean>} processed - The object tracking processed components.\n * @param {Object.<string, any>} sharedFunctions - The map of shared component functions.\n */\nexport function addComponentAndDependencies (componentId, processed, sharedFunctions) {\n  if (!processed[componentId] && sharedFunctions[componentId]) {\n    processed[componentId] = true\n\n    // Add all dependencies of this component\n    const dependencies = sharedFunctions[componentId].components || []\n    for (const depId of dependencies) {\n      addComponentAndDependencies(depId, processed, sharedFunctions)\n    }\n  }\n}\n\n/**\n * Recursively clones an AST node and its children, stripping circular references\n * and assigning unique IDs for client-side hydration.\n *\n * @param {Array<Object>} nodes - The nodes to clean.\n * @param {WeakMap} nodeMap - Map to track original nodes to their unique IDs.\n * @param {Object} state - Object containing the current node counter.\n * @returns {Array<Object>|null} The cleaned AST nodes.\n */\nexport function cleanAST (nodes, nodeMap, state) {\n  if (!nodes) {\n    return null\n  }\n\n  return nodes.map((node) => {\n    const cloned = { ...node }\n    // Assign unique ID for token mapping\n    const id = state.counter++\n    nodeMap.set(node, id)\n    cloned._id = id\n\n    // Remove circular references\n    delete cloned.parent\n    delete cloned.prev\n    delete cloned.next\n    delete cloned.slots\n\n    if (cloned.children) {\n      cloned.children = cleanAST(cloned.children, nodeMap, state)\n    }\n    return cloned\n  })\n}\n\n/**\n * Cleans the template values object, mapping original node references to unique IDs.\n *\n * @param {Object} values - The values object to clean.\n * @param {WeakMap} nodeMap - Map of original nodes to their unique IDs.\n * @returns {Object|null} The cleaned values object.\n */\nexport function cleanValues (values, nodeMap) {\n  if (!values) {\n    return null\n  }\n\n  const result = { ...values }\n\n  if (result.attributes) {\n    result.attributes = result.attributes.map(item => {\n      const cloned = { ...item }\n      cloned.elementId = nodeMap.get(item.element)\n      delete cloned.element\n      return cloned\n    })\n  }\n\n  if (result.textNodes) {\n    result.textNodes = result.textNodes.map(item => {\n      const cloned = { ...item }\n      cloned.textNodeId = nodeMap.get(item.textNode)\n      delete cloned.textNode\n      return cloned\n    })\n  }\n\n  if (result.refs) {\n    result.refs = result.refs.map(item => {\n      const cloned = { ...item }\n      cloned.elementId = nodeMap.get(item.element)\n      delete cloned.element\n      return cloned\n    })\n  }\n  return result\n}\n\n/**\n * Safely merges partial plugin updates into the main context object.\n * Deeply merges plain objects and overwrites other types (arrays, primitives, etc.).\n *\n * @param {any} current - The current state object.\n * @param {any} patch - The patch object containing updates.\n * @returns {any} The newly merged state object.\n */\nexport function mergePluginState (current, patch) {\n  if (!patch || typeof patch !== 'object') {\n    return current\n  }\n\n  const result = { ...current }\n\n  for (const key of Object.keys(patch)) {\n    const patchValue = patch[key]\n    const currentValue = result[key]\n\n    // If both are plain objects, merge them deeply\n    if (\n      patchValue && typeof patchValue === 'object' && !Array.isArray(patchValue) &&\n      currentValue && typeof currentValue === 'object' && !Array.isArray(currentValue)\n    ) {\n      result[key] = mergePluginState(currentValue, patchValue)\n    } else {\n      // Otherwise, overwrite (Arrays, strings, numbers, etc.)\n      result[key] = patchValue\n    }\n  }\n\n  return result\n}\n\n/**\n * Creates a reactive proxy that triggers a callback on changes.\n * Supports deep reactivity via lazy proxying of nested objects.\n *\n * @param {Object} target - The object to proxy.\n * @param {Function} onChange - Callback triggered when a property is set or deleted.\n * @param {WeakMap} [proxies=new WeakMap()] - Cache for existing proxies to handle circular references and identity.\n * @returns {Proxy} The reactive proxy.\n */\nexport function createReactiveProxy (target, onChange, proxies = new WeakMap()) {\n  if (proxies.has(target)) {\n    return proxies.get(target)\n  }\n\n  const handler = {\n    get (target, property, receiver) {\n      const value = Reflect.get(target, property, receiver)\n      if (value !== null && typeof value === 'object' && !(typeof Node !== 'undefined' && value instanceof Node)) {\n        return createReactiveProxy(value, onChange, proxies)\n      }\n      return value\n    },\n    set (target, property, value, receiver) {\n      const oldValue = target[property]\n      if (oldValue === value && property in target) {\n        return true\n      }\n\n      const result = Reflect.set(target, property, value, receiver)\n      if (result) {\n        onChange({\n          property,\n          value,\n          oldValue,\n          target\n        })\n      }\n      return result\n    },\n    deleteProperty (target, property) {\n      const hadProperty = Object.prototype.hasOwnProperty.call(target, property)\n      const oldValue = target[property]\n      const result = Reflect.deleteProperty(target, property)\n      if (result && hadProperty) {\n        onChange({\n          property,\n          value: undefined,\n          oldValue,\n          target,\n          deleted: true\n        })\n      }\n      return result\n    }\n  }\n\n  const proxy = new Proxy(target, handler)\n  proxies.set(target, proxy)\n  return proxy\n}\n\n/**\n * Creates a read-only proxy that throws on mutation attempts.\n * @param {Object} target - The object to proxy.\n * @param {WeakMap} [proxies=new WeakMap()] - Cache for existing proxies.\n * @returns {Proxy} The read-only proxy.\n */\nexport function createReadOnlyProxy (target, proxies = new WeakMap()) {\n  if (proxies.has(target)) {\n    return proxies.get(target)\n  }\n\n  const handler = {\n    get (target, property, receiver) {\n      const value = Reflect.get(target, property, receiver)\n      if (value !== null && typeof value === 'object' && !(typeof Node !== 'undefined' && value instanceof Node)) {\n        return createReadOnlyProxy(value, proxies)\n      }\n      return value\n    },\n    set () {\n      throw new CoraliteError('Cannot mutate state inside a getter. State is read-only here.')\n    },\n    deleteProperty () {\n      throw new CoraliteError('Cannot delete state inside a getter. State is read-only here.')\n    }\n  }\n\n  const proxy = new Proxy(target, handler)\n\n  proxies.set(target, proxy)\n\n  return proxy\n}\n\n/**\n * Defines a Coralite component.\n * On the client, this acts as an identity function for type safety and HRM.\n * @param {Object} options - Component options\n * @returns {Object} The component options\n */\nexport function defineComponent (options) {\n  return options\n}\n"],
+  "mappings": "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",
+  "names": ["target"]
+}