mtrl-addons 0.5.6 → 0.7.0

package/dist/core/layout/index.mjs

@@ -0,0 +1,720 @@
+// src/core/layout/schema.ts
+class FragmentPool {
+  pool = [];
+  maxSize = 8;
+  get() {
+    return this.pool.pop() || document.createDocumentFragment();
+  }
+  release(fragment) {
+    if (this.pool.length < this.maxSize && fragment.childNodes.length === 0) {
+      this.pool.push(fragment);
+    }
+  }
+  clear() {
+    this.pool.length = 0;
+  }
+}
+var fragmentPool = new FragmentPool;
+var classCache = new Map;
+var PREFIX = "mtrl";
+var PREFIX_WITH_DASH = `${PREFIX}-`;
+function getCachedClassName(type, property, value) {
+  const key = `${type}-${property}-${value}`;
+  if (!classCache.has(key)) {
+    if (type === "item") {
+      classCache.set(key, property === "" ? `layout__item--${value}` : `layout__item--${property}-${value}`);
+    } else {
+      if (property === "align") {
+        classCache.set(key, `layout--${type}-${value}`);
+      } else {
+        classCache.set(key, `layout--${type}-${property}-${value}`);
+      }
+    }
+  }
+  return classCache.get(key);
+}
+function isComponent(value) {
+  return value && typeof value === "object" && "element" in value;
+}
+function createFragment() {
+  return fragmentPool.get();
+}
+function releaseFragment(fragment) {
+  fragmentPool.release(fragment);
+}
+function processClassNames(options, skipPrefix = false) {
+  if (!options)
+    return options;
+  const hasRawClass = options.rawClass;
+  const hasRegularClass = options.class || options.className;
+  if (!hasRawClass && !hasRegularClass)
+    return options;
+  if (hasRawClass && !hasRegularClass && skipPrefix) {
+    const processed2 = { ...options };
+    delete processed2.rawClass;
+    if (typeof hasRawClass === "string") {
+      processed2.class = hasRawClass;
+    } else {
+      processed2.class = hasRawClass.join(" ");
+    }
+    return processed2;
+  }
+  const processed = { ...options };
+  let finalClasses = "";
+  if (!skipPrefix && hasRegularClass) {
+    let prefixedString = "";
+    if (processed.class) {
+      prefixedString += Array.isArray(processed.class) ? processed.class.join(" ") : processed.class;
+    }
+    if (processed.className) {
+      prefixedString += (prefixedString ? " " : "") + processed.className;
+    }
+    if (prefixedString) {
+      finalClasses = prefixedString.split(/\s+/).filter(Boolean).map((cls) => cls.startsWith(PREFIX_WITH_DASH) ? cls : PREFIX_WITH_DASH + cls).join(" ");
+    }
+  }
+  if (hasRawClass) {
+    const rawString = Array.isArray(hasRawClass) ? hasRawClass.filter(Boolean).join(" ") : hasRawClass;
+    finalClasses += (finalClasses ? " " : "") + rawString;
+  }
+  if (finalClasses) {
+    processed.class = finalClasses;
+  }
+  delete processed.className;
+  delete processed.rawClass;
+  return processed;
+}
+function extractParameters(schema, startIndex, defaultCreator) {
+  const items = schema.slice(startIndex, startIndex + 3);
+  let creator, name, options;
+  let consumed = 1;
+  const [first, second, third] = items;
+  if (typeof first === "function") {
+    creator = first;
+    if (typeof second === "string") {
+      name = second;
+      consumed = 2;
+      if (isObject(third)) {
+        options = third;
+        consumed = 3;
+      }
+    } else if (isObject(second)) {
+      options = second;
+      consumed = 2;
+    }
+  } else if (typeof first === "string") {
+    creator = defaultCreator;
+    name = first;
+    if (isObject(second)) {
+      options = second;
+      consumed = 2;
+    }
+  } else if (isObject(first)) {
+    creator = defaultCreator;
+    options = first;
+  }
+  return {
+    creator: creator || defaultCreator,
+    name,
+    options: options || {},
+    consumed
+  };
+}
+function isObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function createElement(options = {}) {
+  const tag = options.tag || "div";
+  const element = document.createElement(tag);
+  if (options.class) {
+    element.className = options.class;
+  }
+  if (options.style) {
+    if (typeof options.style === "string") {
+      element.setAttribute("style", options.style);
+    } else if (typeof options.style === "object") {
+      Object.assign(element.style, options.style);
+    }
+  }
+  if (options.textContent) {
+    element.textContent = options.textContent;
+  }
+  if (options.text) {
+    element.textContent = options.text;
+  }
+  return element;
+}
+function addClass(element, className) {
+  if (element && className) {
+    element.classList.add(className);
+  }
+}
+function hasClass(element, className) {
+  return element && element.classList.contains(className);
+}
+function createComponentInstance(Component, options = {}) {
+  try {
+    const {
+      layout: layoutConfig,
+      layoutItem: layoutItemConfig,
+      style: styleConfig,
+      attributes: attributesConfig,
+      events: eventsConfig,
+      event,
+      ...cleanOptions
+    } = options;
+    const finalEventsConfig = eventsConfig || event;
+    if (styleConfig && typeof styleConfig === "string") {
+      cleanOptions.style = styleConfig;
+    }
+    const isClass = typeof Component === "function" && Object.getOwnPropertyDescriptor(Component, "prototype")?.writable === false;
+    const component = isClass ? new Component(cleanOptions) : Component(cleanOptions);
+    if (component) {
+      const element = component.element || (component instanceof HTMLElement ? component : null);
+      if (element) {
+        if (layoutConfig)
+          applyLayoutClasses(element, layoutConfig);
+        if (layoutItemConfig)
+          applyLayoutItemClasses(element, layoutItemConfig);
+        if (styleConfig && typeof styleConfig === "object") {
+          Object.assign(element.style, styleConfig);
+        }
+        if (attributesConfig && typeof attributesConfig === "object") {
+          for (const [key, value] of Object.entries(attributesConfig)) {
+            if (value !== undefined && value !== null) {
+              element.setAttribute(key, value.toString());
+            }
+          }
+        }
+        if (finalEventsConfig && typeof finalEventsConfig === "object") {
+          if (Array.isArray(finalEventsConfig)) {
+            for (const eventDef of finalEventsConfig) {
+              if (Array.isArray(eventDef) && eventDef.length >= 2) {
+                const [eventName, handler] = eventDef;
+                if (typeof eventName === "string" && typeof handler === "function") {
+                  element.addEventListener(eventName, handler);
+                }
+              }
+            }
+          } else {
+            for (const [eventName, handler] of Object.entries(finalEventsConfig)) {
+              if (typeof handler === "function") {
+                element.addEventListener(eventName, handler);
+              }
+            }
+          }
+        }
+      }
+    }
+    return component;
+  } catch (error) {
+    console.error("Error creating component instance:", error);
+    return document.createElement("div");
+  }
+}
+function applyLayoutClasses(element, layoutConfig) {
+  if (!element || !layoutConfig)
+    return;
+  if (layoutConfig.type) {
+    addClass(element, `${PREFIX_WITH_DASH}layout--${layoutConfig.type}`);
+  }
+  const layoutType = layoutConfig.type || getLayoutType(element);
+  if (layoutType) {
+    if (layoutConfig.gap !== undefined) {
+      addClass(element, PREFIX_WITH_DASH + getCachedClassName(layoutType, "gap", layoutConfig.gap));
+    }
+    if (layoutConfig.align) {
+      addClass(element, PREFIX_WITH_DASH + getCachedClassName(layoutType, "align", layoutConfig.align));
+    }
+    if (layoutConfig.justify) {
+      addClass(element, PREFIX_WITH_DASH + getCachedClassName(layoutType, "justify", layoutConfig.justify));
+    }
+  }
+  if (layoutConfig.type === "grid" || getLayoutType(element) === "grid") {
+    if (typeof layoutConfig.columns === "number") {
+      addClass(element, PREFIX_WITH_DASH + getCachedClassName("grid", "cols", layoutConfig.columns));
+    } else if (layoutConfig.columns === "auto-fill") {
+      addClass(element, PREFIX_WITH_DASH + getCachedClassName("grid", "fill", "auto"));
+    } else if (layoutConfig.columns === "auto-fit") {
+      addClass(element, PREFIX_WITH_DASH + getCachedClassName("grid", "cols", "auto-fit"));
+    }
+    if (layoutConfig.dense)
+      addClass(element, `${PREFIX_WITH_DASH}layout--grid-dense`);
+    if (layoutConfig.autoHeight)
+      addClass(element, `${PREFIX_WITH_DASH}layout--grid-auto-height`);
+  }
+  if (layoutConfig.type === "row" || getLayoutType(element) === "row") {
+    if (layoutConfig.wrap === false || layoutConfig.wrap === "nowrap") {
+      addClass(element, `${PREFIX_WITH_DASH}layout--row-nowrap`);
+    } else if (layoutConfig.wrap === "reverse") {
+      addClass(element, `${PREFIX_WITH_DASH}layout--row-wrap-reverse`);
+    }
+    if (layoutConfig.mobileStack)
+      addClass(element, `${PREFIX_WITH_DASH}layout--row-mobile-stack`);
+    if (layoutConfig.mobileScroll)
+      addClass(element, `${PREFIX_WITH_DASH}layout--row-mobile-scroll`);
+  }
+  if (layoutConfig.class) {
+    layoutConfig.class.split(" ").filter(Boolean).forEach((cls) => element.classList.add(cls));
+  }
+}
+function applyLayoutItemClasses(element, itemConfig) {
+  if (!element || !itemConfig)
+    return;
+  addClass(element, `${PREFIX_WITH_DASH}layout__item`);
+  if (itemConfig.width && itemConfig.width >= 1 && itemConfig.width <= 12) {
+    addClass(element, PREFIX_WITH_DASH + getCachedClassName("item", "", itemConfig.width));
+  }
+  if (itemConfig.sm)
+    addClass(element, PREFIX_WITH_DASH + getCachedClassName("item", "sm", itemConfig.sm));
+  if (itemConfig.md)
+    addClass(element, PREFIX_WITH_DASH + getCachedClassName("item", "md", itemConfig.md));
+  if (itemConfig.lg)
+    addClass(element, PREFIX_WITH_DASH + getCachedClassName("item", "lg", itemConfig.lg));
+  if (itemConfig.xl)
+    addClass(element, PREFIX_WITH_DASH + getCachedClassName("item", "xl", itemConfig.xl));
+  if (itemConfig.span)
+    addClass(element, PREFIX_WITH_DASH + getCachedClassName("item", "span", itemConfig.span));
+  if (itemConfig.rowSpan)
+    addClass(element, PREFIX_WITH_DASH + getCachedClassName("item", "row-span", itemConfig.rowSpan));
+  if (itemConfig.order)
+    addClass(element, PREFIX_WITH_DASH + getCachedClassName("item", "order", itemConfig.order));
+  if (itemConfig.align)
+    addClass(element, PREFIX_WITH_DASH + getCachedClassName("item", "self", itemConfig.align));
+  if (itemConfig.auto)
+    addClass(element, `${PREFIX_WITH_DASH}layout__item--auto`);
+}
+function getLayoutType(element) {
+  return hasClass(element, `${PREFIX_WITH_DASH}layout--stack`) ? "stack" : hasClass(element, `${PREFIX_WITH_DASH}layout--row`) ? "row" : hasClass(element, `${PREFIX_WITH_DASH}layout--grid`) ? "grid" : "";
+}
+function processArraySchema(schema, parentElement = null, level = 0, options = {}) {
+  level++;
+  const layout = {};
+  const components = [];
+  const fragment = createFragment();
+  let component = null;
+  if (!Array.isArray(schema)) {
+    return createLayoutResult(layout);
+  }
+  const defaultCreator = options.creator || createElement;
+  for (let i = 0;i < schema.length; i++) {
+    const item = schema[i];
+    if (!item)
+      continue;
+    if (Array.isArray(item)) {
+      const container = component || parentElement;
+      const result = processArraySchema(item, container, level, options);
+      if (Array.isArray(result.layout.components)) {
+        components.push(...result.layout.components);
+        delete result.layout.components;
+      }
+      Object.assign(layout, result.layout);
+      continue;
+    }
+    const {
+      creator,
+      name,
+      options: itemOptions,
+      consumed
+    } = extractParameters(schema, i, defaultCreator);
+    if (!creator) {
+      console.warn("Skipping unsupported item type:", item);
+      continue;
+    }
+    if (creator === createElement && !("tag" in itemOptions)) {
+      itemOptions.tag = "div";
+    }
+    i += consumed - 1;
+    const shouldApplyPrefix = "prefix" in itemOptions ? itemOptions.prefix : options.prefix !== false;
+    const processedOptions = shouldApplyPrefix || itemOptions.rawClass ? processClassNames(itemOptions, !shouldApplyPrefix) : itemOptions;
+    if (name && !("name" in processedOptions) && !(creator === createElement || creator.isElement)) {
+      processedOptions.name = name;
+    }
+    component = createComponentInstance(creator, processedOptions);
+    const element = isComponent(component) ? component.element : component;
+    if (level === 1)
+      layout.element = element;
+    if (name) {
+      layout[name] = component;
+      components.push([name, component]);
+    }
+    if (component) {
+      if ("insert" in component && typeof component.insert === "function") {
+        component.insert(fragment);
+      } else {
+        fragment.appendChild(element);
+      }
+      if (parentElement) {
+        component._container = parentElement;
+        if ("onInserted" in component && typeof component.onInserted === "function") {
+          component.onInserted(parentElement);
+        }
+      }
+    }
+  }
+  if (parentElement && fragment.hasChildNodes()) {
+    const wrapper = isComponent(parentElement) ? parentElement.element : parentElement;
+    wrapper.appendChild(fragment);
+  }
+  releaseFragment(fragment);
+  layout.components = components;
+  return createLayoutResult(layout);
+}
+function processObjectSchema(schema, parentElement = null, options = {}) {
+  const layout = {};
+  const defaultCreator = options.creator || createElement;
+  if (schema.element && !parentElement) {
+    const elementDef = schema.element;
+    const createElementFn = elementDef.creator || defaultCreator;
+    const elementOptions = elementDef.options || {};
+    const processedOptions = options.prefix !== false ? processClassNames(elementOptions) : { ...elementOptions };
+    const rootComponent = createComponentInstance(createElementFn, processedOptions);
+    layout.element = rootComponent;
+    if (elementDef.name)
+      layout[elementDef.name] = rootComponent;
+    if (elementDef.children) {
+      const rootElement = isComponent(rootComponent) ? rootComponent.element : rootComponent;
+      const childResult = processObjectSchema(elementDef.children, rootElement, options);
+      Object.assign(layout, childResult.layout);
+    }
+    return createLayoutResult(layout);
+  }
+  const fragment = parentElement ? createFragment() : null;
+  for (const key in schema) {
+    const def = schema[key];
+    if (!def)
+      continue;
+    const elementCreator = def.creator || defaultCreator;
+    const elementOptions = def.options || {};
+    const shouldApplyPrefix = "prefix" in elementOptions ? elementOptions.prefix : options.prefix !== false;
+    const processedOptions = shouldApplyPrefix ? processClassNames(elementOptions) : { ...elementOptions };
+    if (!def.name && key !== "element") {
+      def.name = key;
+    }
+    const created = createComponentInstance(elementCreator, processedOptions);
+    layout[key] = created;
+    if (def.name && def.name !== key)
+      layout[def.name] = created;
+    const element = isComponent(created) ? created.element : created;
+    if (fragment)
+      fragment.appendChild(element);
+    if (def.children) {
+      const childResult = processObjectSchema(def.children, element, options);
+      Object.assign(layout, childResult.layout);
+    }
+  }
+  if (parentElement && fragment) {
+    const parentDom = isComponent(parentElement) ? parentElement.element : parentElement;
+    parentDom.appendChild(fragment);
+    releaseFragment(fragment);
+  }
+  return createLayoutResult(layout);
+}
+function flattenLayout(layout) {
+  const flattened = {};
+  if (!layout || typeof layout !== "object")
+    return flattened;
+  for (const key in layout) {
+    const value = layout[key];
+    if (value && typeof value !== "function" && (value instanceof HTMLElement || typeof SVGElement !== "undefined" && value instanceof SVGElement || isComponent(value))) {
+      flattened[key] = value;
+    }
+  }
+  return flattened;
+}
+function createLayoutResult(layout) {
+  const flattenedComponents = flattenLayout(layout);
+  return {
+    layout,
+    element: layout.element,
+    component: flattenedComponents,
+    get(name) {
+      return layout[name] ?? null;
+    },
+    getAll() {
+      return flattenedComponents;
+    },
+    destroy() {
+      const destroyed = new Set;
+      const destroyComponent = (component) => {
+        if (!component || destroyed.has(component))
+          return;
+        if (component instanceof HTMLElement || typeof component !== "object")
+          return;
+        if (typeof component.destroy === "function") {
+          destroyed.add(component);
+          try {
+            component.destroy();
+          } catch (e) {}
+        }
+      };
+      if (Array.isArray(layout.components)) {
+        for (const [name, component] of layout.components) {
+          destroyComponent(component);
+        }
+      }
+      for (const key in layout) {
+        if (key === "element" || key === "components")
+          continue;
+        destroyComponent(layout[key]);
+      }
+      if (Array.isArray(layout.components)) {
+        layout.components.length = 0;
+      }
+      if (layout.element) {
+        const element = isComponent(layout.element) ? layout.element.element : layout.element;
+        if (element && element.parentNode) {
+          element.parentNode.removeChild(element);
+        }
+      }
+      for (const key in layout) {
+        delete layout[key];
+      }
+    }
+  };
+}
+function createLayout(schema, parentElement = null, options = {}) {
+  if (typeof schema === "function") {
+    schema = schema();
+  }
+  if (typeof schema === "string") {
+    const template = document.createElement("template");
+    template.innerHTML = schema.trim();
+    const fragment = template.content;
+    if (parentElement && fragment.hasChildNodes()) {
+      parentElement.appendChild(fragment);
+    }
+    const layout = { element: fragment.firstElementChild };
+    return createLayoutResult(layout);
+  }
+  if (Array.isArray(schema) && schema.length >= 3 && typeof schema[0] === "function" && typeof schema[1] === "string" && isObject(schema[2])) {
+    return processArraySchema(schema, parentElement, 0, options);
+  }
+  return Array.isArray(schema) ? processArraySchema(schema, parentElement, 0, options) : processObjectSchema(schema, parentElement, options);
+}
+function clearClassCache() {
+  classCache.clear();
+}
+function clearFragmentPool() {
+  fragmentPool.clear();
+}
+// src/core/layout/config.ts
+var PREFIX2 = "mtrl";
+var PREFIX_WITH_DASH2 = `${PREFIX2}-`;
+function addClass2(element, className) {
+  if (element && className && element.classList) {
+    element.classList.add(className);
+  }
+}
+function hasClass2(element, className) {
+  return element && element.classList && element.classList.contains(className);
+}
+function cleanupLayoutClasses(element) {
+  if (!element || !element.classList)
+    return;
+  const classList = Array.from(element.classList);
+  const layoutClasses = classList.filter((cls) => cls.startsWith(`${PREFIX_WITH_DASH2}layout--`) || cls.includes(`-${PREFIX_WITH_DASH2}layout--`));
+  layoutClasses.forEach((cls) => {
+    element.classList.remove(cls);
+  });
+}
+function getLayoutType2(element) {
+  return hasClass2(element, `${PREFIX_WITH_DASH2}layout--stack`) ? "stack" : hasClass2(element, `${PREFIX_WITH_DASH2}layout--row`) ? "row" : hasClass2(element, `${PREFIX_WITH_DASH2}layout--grid`) ? "grid" : "";
+}
+function getLayoutPrefix() {
+  return PREFIX_WITH_DASH2;
+}
+function setLayoutClasses(element, layoutType, classes = []) {
+  if (!element || !layoutType)
+    return;
+  cleanupLayoutClasses(element);
+  addClass2(element, `${PREFIX_WITH_DASH2}layout--${layoutType}`);
+  classes.forEach((cls) => {
+    if (cls.startsWith("layout--") || cls.startsWith("layout__")) {
+      addClass2(element, `${PREFIX_WITH_DASH2}${cls}`);
+    } else {
+      addClass2(element, cls);
+    }
+  });
+}
+// src/core/layout/jsx.ts
+var Fragment = Symbol("Fragment");
+function h(tag, props, ...children) {
+  if (tag === Fragment) {
+    const fragment = document.createDocumentFragment();
+    children.forEach((child) => {
+      if (child != null) {
+        const element = typeof child === "string" ? document.createTextNode(child) : child;
+        fragment.appendChild(element);
+      }
+    });
+    return fragment;
+  }
+  if (typeof tag === "string") {
+    const element = document.createElement(tag);
+    if (props) {
+      for (const [key, value] of Object.entries(props)) {
+        if (key === "className" || key === "class") {
+          element.className = value;
+        } else if (key.startsWith("on") && typeof value === "function") {
+          const eventName = key.slice(2).toLowerCase();
+          element.addEventListener(eventName, value);
+        } else if (key === "style" && typeof value === "object") {
+          Object.assign(element.style, value);
+        } else if (key === "dangerouslySetInnerHTML") {
+          element.innerHTML = value.__html || "";
+        } else if (value != null) {
+          element.setAttribute(key, value.toString());
+        }
+      }
+    }
+    children.forEach((child) => {
+      if (child != null) {
+        if (typeof child === "string") {
+          element.appendChild(document.createTextNode(child));
+        } else if (child instanceof Node) {
+          element.appendChild(child);
+        } else {
+          element.appendChild(document.createTextNode(String(child)));
+        }
+      }
+    });
+    return element;
+  }
+  if (typeof tag === "function") {
+    const allProps = props || {};
+    if (children.length > 0) {
+      allProps.children = children;
+    }
+    return tag(allProps);
+  }
+  return h("div", props, ...children);
+}
+function createJsxLayout(jsxElement, parentElement) {
+  const schema = jsxElement;
+  return createLayout(schema, parentElement);
+}
+function component(fn) {
+  return function(props) {
+    return fn(props || {});
+  };
+}
+function renderElements(elements, parentElement) {
+  return elements.map((element) => createJsxLayout(element, parentElement));
+}
+var jsx = {
+  div: (props, ...children) => h("div", props, ...children),
+  span: (props, ...children) => h("span", props, ...children),
+  p: (props, ...children) => h("p", props, ...children),
+  button: (props, ...children) => h("button", props, ...children),
+  input: (props) => h("input", props),
+  img: (props) => h("img", props),
+  a: (props, ...children) => h("a", props, ...children),
+  ul: (props, ...children) => h("ul", props, ...children),
+  li: (props, ...children) => h("li", props, ...children),
+  section: (props, ...children) => h("section", props, ...children),
+  header: (props, ...children) => h("header", props, ...children),
+  footer: (props, ...children) => h("footer", props, ...children),
+  main: (props, ...children) => h("main", props, ...children),
+  article: (props, ...children) => h("article", props, ...children)
+};
+
+// src/core/layout/index.ts
+function layout(type = "stack", options = {}) {
+  return createLayout([
+    "div",
+    {
+      layout: { type },
+      ...options
+    }
+  ]);
+}
+function grid(columns = "auto-fit", options = {}) {
+  return createLayout([
+    "div",
+    {
+      layout: {
+        type: "grid",
+        columns,
+        gap: options.gap || "1rem",
+        ...options.layout
+      },
+      ...options
+    }
+  ]);
+}
+function row(options = {}) {
+  return createLayout([
+    "div",
+    {
+      layout: {
+        type: "row",
+        gap: options.gap || "1rem",
+        mobileStack: options.mobileStack !== false,
+        ...options.layout
+      },
+      ...options
+    }
+  ]);
+}
+function stack(options = {}) {
+  return createLayout([
+    "div",
+    {
+      layout: {
+        type: "stack",
+        gap: options.gap || "1rem",
+        ...options.layout
+      },
+      ...options
+    }
+  ]);
+}
+function template(fn, props = {}) {
+  const schema = fn(props);
+  return createLayout(schema);
+}
+var performance = {
+  clearCache: clearClassCache,
+  clearFragmentPool,
+  clearAll() {
+    clearClassCache();
+    clearFragmentPool();
+  },
+  getStats() {
+    return {
+      message: "Performance stats available in browser console"
+    };
+  }
+};
+export {
+  template,
+  stack,
+  setLayoutClasses,
+  row,
+  renderElements,
+  processClassNames,
+  performance,
+  layout,
+  jsx,
+  isComponent,
+  h,
+  grid,
+  getLayoutType2 as getLayoutType,
+  getLayoutPrefix,
+  flattenLayout,
+  createLayout as default,
+  createLayoutResult,
+  createLayout,
+  createJsxLayout,
+  component,
+  clearFragmentPool,
+  clearClassCache,
+  cleanupLayoutClasses,
+  applyLayoutItemClasses,
+  applyLayoutClasses,
+  Fragment
+};
+
+//# debugId=8F4403D255F8A70864756E2164756E21
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/core/layout/schema.ts", "../../../src/core/layout/config.ts", "../../../src/core/layout/jsx.ts", "../../../src/core/layout/index.ts"],
  "sourcesContent": [
    "/**\n * @module core/layout/schema\n * @description Unified layout schema processor with integrated optimizations\n * Consolidates array, object, JSX, and template processing with built-in performance enhancements\n */\n\n// ============================================================================\n// TYPES (Essential only)\n// ============================================================================\n\nexport interface LayoutConfig {\n  /** Base layout type */\n  type?: \"stack\" | \"row\" | \"grid\" | string;\n  /** Spacing between elements */\n  gap?: number | string;\n  /** Additional CSS classes */\n  class?: string;\n  /** Alignment of items along the cross axis */\n  align?: \"start\" | \"center\" | \"end\" | \"stretch\";\n  /** Alignment of items along the main axis */\n  justify?: \"start\" | \"center\" | \"end\" | \"between\" | \"around\" | \"evenly\";\n  /** Whether and how items should wrap */\n  wrap?: boolean | \"reverse\" | \"nowrap\";\n  /** Whether row items should stack vertically on mobile */\n  mobileStack?: boolean;\n  /** Whether row items should scroll horizontally on mobile */\n  mobileScroll?: boolean;\n  /** Number of columns or automatic sizing method */\n  columns?: number | \"auto-fit\" | \"auto-fill\";\n  /** Whether to use dense packing algorithm for grid */\n  dense?: boolean;\n  /** Whether grid items should adjust height automatically */\n  autoHeight?: boolean;\n}\n\nexport interface LayoutItemConfig {\n  /** Column width in a 12-column grid */\n  width?: number;\n  /** Width on small screens */\n  sm?: number;\n  /** Width on medium screens */\n  md?: number;\n  /** Width on large screens */\n  lg?: number;\n  /** Width on extra-large screens */\n  xl?: number;\n  /** Number of grid columns to span */\n  span?: number;\n  /** Number of grid rows to span */\n  rowSpan?: number;\n  /** Display order */\n  order?: number | \"first\" | \"last\";\n  /** Self-alignment within container */\n  align?: \"start\" | \"center\" | \"end\" | \"stretch\";\n  /** Whether item should automatically size */\n  auto?: boolean;\n}\n\nexport interface LayoutOptions {\n  /** Default creator function to use if not specified in schema */\n  creator?: Function;\n  /** Whether to apply CSS class prefix @default true */\n  prefix?: boolean;\n  /** Additional options */\n  [key: string]: any;\n}\n\nexport interface LayoutResult {\n  /** The raw layout object with all components */\n  layout: Record<string, any>;\n  /** Reference to the root element for convenience */\n  element: HTMLElement | any;\n  /** Flattened component map */\n  component: Record<string, any>;\n  /** Gets a component by name */\n  get(name: string): any;\n  /** Gets all components in a flattened map */\n  getAll(): Record<string, any>;\n  /** Destroys the layout, cleaning up all components */\n  destroy(): void;\n}\n\ntype ComponentLike = { element: HTMLElement; [key: string]: any };\ntype SchemaItem = Function | string | Record<string, any> | SchemaItem[];\n\n// ============================================================================\n// BUILT-IN OPTIMIZATIONS\n// ============================================================================\n\n/**\n * Fragment Pool for efficient DocumentFragment reuse\n * Reduces GC pressure in high-frequency layout creation scenarios\n */\nclass FragmentPool {\n  private pool: DocumentFragment[] = [];\n  private maxSize = 8; // Optimized size for memory efficiency\n\n  get(): DocumentFragment {\n    return this.pool.pop() || document.createDocumentFragment();\n  }\n\n  release(fragment: DocumentFragment): void {\n    if (this.pool.length < this.maxSize && fragment.childNodes.length === 0) {\n      this.pool.push(fragment);\n    }\n  }\n\n  clear(): void {\n    this.pool.length = 0;\n  }\n}\n\nconst fragmentPool = new FragmentPool();\n\n/**\n * Class name cache for layout configurations\n * Reduces string operations by caching generated class names\n */\nconst classCache = new Map<string, string>();\n\n// Configuration constants\nconst PREFIX = \"mtrl\"; // TODO: Make this configurable\nconst PREFIX_WITH_DASH = `${PREFIX}-`;\n\n/**\n * Gets a cached class name for layout configuration\n * Optimized for different class naming patterns\n */\nfunction getCachedClassName(\n  type: string,\n  property: string,\n  value: string | number,\n): string {\n  const key = `${type}-${property}-${value}`;\n  if (!classCache.has(key)) {\n    if (type === \"item\") {\n      classCache.set(\n        key,\n        property === \"\"\n          ? `layout__item--${value}`\n          : `layout__item--${property}-${value}`,\n      );\n    } else {\n      // For layout classes, align uses layout--{type}-{value}\n      // but justify and others use layout--{type}-{property}-{value}\n      if (property === \"align\") {\n        classCache.set(key, `layout--${type}-${value}`);\n      } else {\n        classCache.set(key, `layout--${type}-${property}-${value}`);\n      }\n    }\n  }\n  return classCache.get(key)!;\n}\n\n// ============================================================================\n// OPTIMIZED UTILITIES\n// ============================================================================\n\n/**\n * Checks if a value is a component object (has an element property)\n */\nfunction isComponent(value: any): value is ComponentLike {\n  return value && typeof value === \"object\" && \"element\" in value;\n}\n\n/**\n * Creates a document fragment using pooling for better performance\n */\nfunction createFragment(): DocumentFragment {\n  return fragmentPool.get();\n}\n\n/**\n * Releases a fragment back to the pool for reuse\n */\nfunction releaseFragment(fragment: DocumentFragment): void {\n  fragmentPool.release(fragment);\n}\n\n/**\n * Optimized class processing with minimal string operations\n * Handles arrays, strings, className aliases, and rawClass efficiently\n */\nfunction processClassNames(\n  options: Record<string, any>,\n  skipPrefix = false,\n): Record<string, any> {\n  if (!options) return options;\n\n  const hasRawClass = options.rawClass;\n  const hasRegularClass = options.class || options.className;\n\n  // Fast path: no class properties at all\n  if (!hasRawClass && !hasRegularClass) return options;\n\n  // Fast path: only rawClass and skipping prefix (most common rawClass scenario)\n  if (hasRawClass && !hasRegularClass && skipPrefix) {\n    const processed = { ...options };\n    delete processed.rawClass;\n\n    // Direct assignment for simple string\n    if (typeof hasRawClass === \"string\") {\n      processed.class = hasRawClass;\n    } else {\n      // Handle array case\n      processed.class = hasRawClass.join(\" \");\n    }\n    return processed;\n  }\n\n  // Full processing path (only when needed)\n  const processed = { ...options };\n  let finalClasses = \"\";\n\n  // Handle prefixed classes only if not skipping prefix\n  if (!skipPrefix && hasRegularClass) {\n    let prefixedString = \"\";\n\n    if (processed.class) {\n      prefixedString += Array.isArray(processed.class)\n        ? processed.class.join(\" \")\n        : processed.class;\n    }\n    if (processed.className) {\n      prefixedString += (prefixedString ? \" \" : \"\") + processed.className;\n    }\n\n    if (prefixedString) {\n      finalClasses = prefixedString\n        .split(/\\s+/)\n        .filter(Boolean)\n        .map((cls) =>\n          cls.startsWith(PREFIX_WITH_DASH) ? cls : PREFIX_WITH_DASH + cls,\n        )\n        .join(\" \");\n    }\n  }\n\n  // Handle rawClass (always processed when present)\n  if (hasRawClass) {\n    const rawString = Array.isArray(hasRawClass)\n      ? hasRawClass.filter(Boolean).join(\" \")\n      : hasRawClass;\n\n    finalClasses += (finalClasses ? \" \" : \"\") + rawString;\n  }\n\n  if (finalClasses) {\n    processed.class = finalClasses;\n  }\n\n  // Clean up in one operation\n  delete processed.className;\n  delete processed.rawClass;\n\n  return processed;\n}\n\n/**\n * Optimized parameter extraction for array schemas\n * Reduces multiple array lookups with batch processing\n */\ninterface ExtractedParameters {\n  creator: Function;\n  name?: string;\n  options: Record<string, any>;\n  consumed: number;\n}\n\nfunction extractParameters(\n  schema: SchemaItem[],\n  startIndex: number,\n  defaultCreator: Function,\n): ExtractedParameters {\n  const items = schema.slice(startIndex, startIndex + 3);\n  let creator, name, options;\n  let consumed = 1;\n\n  const [first, second, third] = items;\n\n  if (typeof first === \"function\") {\n    creator = first;\n    if (typeof second === \"string\") {\n      name = second;\n      consumed = 2;\n      if (isObject(third)) {\n        options = third;\n        consumed = 3;\n      }\n    } else if (isObject(second)) {\n      options = second;\n      consumed = 2;\n    }\n  } else if (typeof first === \"string\") {\n    creator = defaultCreator;\n    name = first;\n    if (isObject(second)) {\n      options = second;\n      consumed = 2;\n    }\n  } else if (isObject(first)) {\n    creator = defaultCreator;\n    options = first;\n  }\n\n  return {\n    creator: creator || defaultCreator,\n    name,\n    options: (options || {}) as Record<string, any>,\n    consumed,\n  };\n}\n\n/**\n * Simple object type check\n */\nfunction isObject(value: any): boolean {\n  return value !== null && typeof value === \"object\" && !Array.isArray(value);\n}\n\n// ============================================================================\n// DOM UTILITIES (Simplified)\n// ============================================================================\n\n/**\n * Simple DOM element creation\n */\nfunction createElement(options: Record<string, any> = {}): HTMLElement {\n  const tag = options.tag || \"div\";\n  const element = document.createElement(tag);\n\n  if (options.class) {\n    element.className = options.class;\n  }\n\n  if (options.style) {\n    if (typeof options.style === \"string\") {\n      element.setAttribute(\"style\", options.style);\n    } else if (typeof options.style === \"object\") {\n      Object.assign(element.style, options.style);\n    }\n  }\n\n  if (options.textContent) {\n    element.textContent = options.textContent;\n  }\n\n  if (options.text) {\n    element.textContent = options.text;\n  }\n\n  return element;\n}\n\n/**\n * Adds a CSS class to an element\n */\nfunction addClass(element: HTMLElement, className: string): void {\n  if (element && className) {\n    element.classList.add(className);\n  }\n}\n\n/**\n * Checks if element has a CSS class\n */\nfunction hasClass(element: HTMLElement, className: string): boolean {\n  return element && element.classList.contains(className);\n}\n\n// ============================================================================\n// UNIFIED COMPONENT CREATION (with destructuring optimization)\n// ============================================================================\n\n/**\n * Creates a component instance with optimized option processing\n * Uses destructuring for cleaner separation of concerns\n */\nfunction createComponentInstance(\n  Component: any,\n  options: Record<string, any> = {},\n): any {\n  try {\n    // Destructure special configs in one operation\n    const {\n      layout: layoutConfig,\n      layoutItem: layoutItemConfig,\n      style: styleConfig,\n      attributes: attributesConfig,\n      events: eventsConfig,\n      event, // Legacy support\n      ...cleanOptions\n    } = options;\n\n    // Use events over event (events is preferred)\n    const finalEventsConfig = eventsConfig || event;\n\n    // If style is a string, always pass it through to the component\n    if (styleConfig && typeof styleConfig === \"string\") {\n      cleanOptions.style = styleConfig;\n    }\n\n    // Create component\n    const isClass =\n      typeof Component === \"function\" &&\n      Object.getOwnPropertyDescriptor(Component, \"prototype\")?.writable ===\n        false;\n\n    const component = isClass\n      ? new Component(cleanOptions)\n      : Component(cleanOptions);\n\n    // Apply configurations if component has element\n    if (component) {\n      const element =\n        component.element ||\n        (component instanceof HTMLElement ? component : null);\n      if (element) {\n        // Apply layout classes\n        if (layoutConfig) applyLayoutClasses(element, layoutConfig);\n\n        // Apply layout item classes\n        if (layoutItemConfig) applyLayoutItemClasses(element, layoutItemConfig);\n\n        // Apply style\n        if (styleConfig && typeof styleConfig === \"object\") {\n          Object.assign(element.style, styleConfig);\n        }\n\n        // Apply attributes\n        if (attributesConfig && typeof attributesConfig === \"object\") {\n          for (const [key, value] of Object.entries(attributesConfig)) {\n            if (value !== undefined && value !== null) {\n              element.setAttribute(key, value.toString());\n            }\n          }\n        }\n\n        // Apply events\n        if (finalEventsConfig && typeof finalEventsConfig === \"object\") {\n          if (Array.isArray(finalEventsConfig)) {\n            for (const eventDef of finalEventsConfig) {\n              if (Array.isArray(eventDef) && eventDef.length >= 2) {\n                const [eventName, handler] = eventDef;\n                if (\n                  typeof eventName === \"string\" &&\n                  typeof handler === \"function\"\n                ) {\n                  element.addEventListener(eventName, handler);\n                }\n              }\n            }\n          } else {\n            for (const [eventName, handler] of Object.entries(\n              finalEventsConfig,\n            )) {\n              if (typeof handler === \"function\") {\n                element.addEventListener(eventName, handler);\n              }\n            }\n          }\n        }\n      }\n    }\n\n    return component;\n  } catch (error) {\n    console.error(\"Error creating component instance:\", error);\n    return document.createElement(\"div\");\n  }\n}\n\n// ============================================================================\n// INTEGRATED LAYOUT CONFIGURATION (with caching)\n// ============================================================================\n\n/**\n * Applies layout classes based on configuration\n * Uses integrated caching for optimal performance\n */\nfunction applyLayoutClasses(\n  element: HTMLElement,\n  layoutConfig: LayoutConfig,\n): void {\n  if (!element || !layoutConfig) return;\n\n  // Apply base layout type\n  if (layoutConfig.type) {\n    addClass(element, `${PREFIX_WITH_DASH}layout--${layoutConfig.type}`);\n  }\n\n  // Apply properties with caching\n  const layoutType = layoutConfig.type || getLayoutType(element);\n  if (layoutType) {\n    if (layoutConfig.gap !== undefined) {\n      addClass(\n        element,\n        PREFIX_WITH_DASH +\n          getCachedClassName(layoutType, \"gap\", layoutConfig.gap),\n      );\n    }\n    if (layoutConfig.align) {\n      addClass(\n        element,\n        PREFIX_WITH_DASH +\n          getCachedClassName(layoutType, \"align\", layoutConfig.align),\n      );\n    }\n    if (layoutConfig.justify) {\n      addClass(\n        element,\n        PREFIX_WITH_DASH +\n          getCachedClassName(layoutType, \"justify\", layoutConfig.justify),\n      );\n    }\n  }\n\n  // Grid-specific properties\n  if (layoutConfig.type === \"grid\" || getLayoutType(element) === \"grid\") {\n    if (typeof layoutConfig.columns === \"number\") {\n      addClass(\n        element,\n        PREFIX_WITH_DASH +\n          getCachedClassName(\"grid\", \"cols\", layoutConfig.columns),\n      );\n    } else if (layoutConfig.columns === \"auto-fill\") {\n      addClass(\n        element,\n        PREFIX_WITH_DASH + getCachedClassName(\"grid\", \"fill\", \"auto\"),\n      );\n    } else if (layoutConfig.columns === \"auto-fit\") {\n      addClass(\n        element,\n        PREFIX_WITH_DASH + getCachedClassName(\"grid\", \"cols\", \"auto-fit\"),\n      );\n    }\n    if (layoutConfig.dense)\n      addClass(element, `${PREFIX_WITH_DASH}layout--grid-dense`);\n    if (layoutConfig.autoHeight)\n      addClass(element, `${PREFIX_WITH_DASH}layout--grid-auto-height`);\n  }\n\n  // Row-specific properties\n  if (layoutConfig.type === \"row\" || getLayoutType(element) === \"row\") {\n    if (layoutConfig.wrap === false || layoutConfig.wrap === \"nowrap\") {\n      addClass(element, `${PREFIX_WITH_DASH}layout--row-nowrap`);\n    } else if (layoutConfig.wrap === \"reverse\") {\n      addClass(element, `${PREFIX_WITH_DASH}layout--row-wrap-reverse`);\n    }\n    if (layoutConfig.mobileStack)\n      addClass(element, `${PREFIX_WITH_DASH}layout--row-mobile-stack`);\n    if (layoutConfig.mobileScroll)\n      addClass(element, `${PREFIX_WITH_DASH}layout--row-mobile-scroll`);\n  }\n\n  // Custom classes\n  if (layoutConfig.class) {\n    layoutConfig.class\n      .split(\" \")\n      .filter(Boolean)\n      .forEach((cls) => element.classList.add(cls));\n  }\n}\n\n/**\n * Applies layout item classes based on configuration\n * Uses integrated caching for optimal performance\n */\nfunction applyLayoutItemClasses(\n  element: HTMLElement,\n  itemConfig: LayoutItemConfig,\n): void {\n  if (!element || !itemConfig) return;\n\n  addClass(element, `${PREFIX_WITH_DASH}layout__item`);\n\n  // Width and responsive classes with caching\n  if (itemConfig.width && itemConfig.width >= 1 && itemConfig.width <= 12) {\n    addClass(\n      element,\n      PREFIX_WITH_DASH + getCachedClassName(\"item\", \"\", itemConfig.width),\n    );\n  }\n  if (itemConfig.sm)\n    addClass(\n      element,\n      PREFIX_WITH_DASH + getCachedClassName(\"item\", \"sm\", itemConfig.sm),\n    );\n  if (itemConfig.md)\n    addClass(\n      element,\n      PREFIX_WITH_DASH + getCachedClassName(\"item\", \"md\", itemConfig.md),\n    );\n  if (itemConfig.lg)\n    addClass(\n      element,\n      PREFIX_WITH_DASH + getCachedClassName(\"item\", \"lg\", itemConfig.lg),\n    );\n  if (itemConfig.xl)\n    addClass(\n      element,\n      PREFIX_WITH_DASH + getCachedClassName(\"item\", \"xl\", itemConfig.xl),\n    );\n\n  // Grid span classes\n  if (itemConfig.span)\n    addClass(\n      element,\n      PREFIX_WITH_DASH + getCachedClassName(\"item\", \"span\", itemConfig.span),\n    );\n  if (itemConfig.rowSpan)\n    addClass(\n      element,\n      PREFIX_WITH_DASH +\n        getCachedClassName(\"item\", \"row-span\", itemConfig.rowSpan),\n    );\n\n  // Order and alignment\n  if (itemConfig.order)\n    addClass(\n      element,\n      PREFIX_WITH_DASH + getCachedClassName(\"item\", \"order\", itemConfig.order),\n    );\n  if (itemConfig.align)\n    addClass(\n      element,\n      PREFIX_WITH_DASH + getCachedClassName(\"item\", \"self\", itemConfig.align),\n    );\n  if (itemConfig.auto)\n    addClass(element, `${PREFIX_WITH_DASH}layout__item--auto`);\n}\n\n/**\n * Gets the layout type from element classes\n */\nfunction getLayoutType(element: HTMLElement): string {\n  return hasClass(element, `${PREFIX_WITH_DASH}layout--stack`)\n    ? \"stack\"\n    : hasClass(element, `${PREFIX_WITH_DASH}layout--row`)\n      ? \"row\"\n      : hasClass(element, `${PREFIX_WITH_DASH}layout--grid`)\n        ? \"grid\"\n        : \"\";\n}\n\n// ============================================================================\n// UNIFIED SCHEMA PROCESSORS\n// ============================================================================\n\n/**\n * Processes array-based schema definitions\n * Optimized with parameter extraction and integrated configuration\n */\nfunction processArraySchema(\n  schema: SchemaItem[] | any,\n  parentElement: HTMLElement | null = null,\n  level: number = 0,\n  options: LayoutOptions = {},\n): LayoutResult {\n  level++;\n  const layout: Record<string, any> = {};\n  const components: Array<[string, any]> = [];\n  const fragment = createFragment();\n  let component = null;\n\n  if (!Array.isArray(schema)) {\n    return createLayoutResult(layout);\n  }\n\n  const defaultCreator = (options as any).creator || createElement;\n\n  for (let i = 0; i < schema.length; i++) {\n    const item = schema[i];\n    if (!item) continue;\n\n    // Handle nested arrays\n    if (Array.isArray(item)) {\n      const container = component || parentElement;\n      const result = processArraySchema(item, container, level, options);\n      // Merge nested components array instead of overwriting\n      if (Array.isArray(result.layout.components)) {\n        components.push(...result.layout.components);\n        delete result.layout.components;\n      }\n      Object.assign(layout, result.layout);\n      continue;\n    }\n\n    // Use optimized parameter extraction\n    const {\n      creator,\n      name,\n      options: itemOptions,\n      consumed,\n    } = extractParameters(schema, i, defaultCreator);\n\n    if (!creator) {\n      console.warn(\"Skipping unsupported item type:\", item);\n      continue;\n    }\n\n    // Default to div for createElement\n    if (creator === createElement && !(\"tag\" in itemOptions)) {\n      itemOptions.tag = \"div\";\n    }\n\n    // Advance index by consumed items minus 1 (loop increment handles the +1)\n    i += consumed - 1;\n\n    // Process options with prefix - optimized decision logic\n    const shouldApplyPrefix =\n      \"prefix\" in itemOptions ? itemOptions.prefix : options.prefix !== false;\n\n    // Fast path: process only when needed\n    const processedOptions =\n      shouldApplyPrefix || itemOptions.rawClass\n        ? processClassNames(itemOptions, !shouldApplyPrefix)\n        : itemOptions; // No copy needed if no processing\n\n    // Add name to options if needed\n    if (\n      name &&\n      !(\"name\" in processedOptions) &&\n      !(creator === createElement || (creator as any).isElement)\n    ) {\n      processedOptions.name = name;\n    }\n\n    // Create component\n    component = createComponentInstance(creator, processedOptions);\n    const element = isComponent(component) ? component.element : component;\n\n    if (level === 1) layout.element = element;\n    if (name) {\n      layout[name] = component;\n      components.push([name, component]);\n    }\n\n    // Append to DOM\n    if (component) {\n      if (\"insert\" in component && typeof component.insert === \"function\") {\n        component.insert(fragment);\n      } else {\n        fragment.appendChild(element);\n      }\n\n      if (parentElement) {\n        component._container = parentElement;\n        if (\n          \"onInserted\" in component &&\n          typeof component.onInserted === \"function\"\n        ) {\n          component.onInserted(parentElement);\n        }\n      }\n    }\n  }\n\n  // Append fragment to parent\n  if (parentElement && fragment.hasChildNodes()) {\n    const wrapper = isComponent(parentElement)\n      ? parentElement.element\n      : parentElement;\n    wrapper.appendChild(fragment);\n  }\n\n  // Release fragment back to pool\n  releaseFragment(fragment);\n\n  layout.components = components;\n  return createLayoutResult(layout);\n}\n\n/**\n * Processes object-based schema definitions\n * Simplified and optimized for better performance\n */\nfunction processObjectSchema(\n  schema: Record<string, any> | string,\n  parentElement: HTMLElement | null = null,\n  options: LayoutOptions = {},\n): LayoutResult {\n  const layout: Record<string, any> = {};\n  const defaultCreator = options.creator || createElement;\n\n  // Handle root element creation\n  if ((schema as any).element && !parentElement) {\n    const elementDef = (schema as any).element;\n    const createElementFn = elementDef.creator || defaultCreator;\n\n    const elementOptions = elementDef.options || {};\n    const processedOptions =\n      options.prefix !== false\n        ? processClassNames(elementOptions)\n        : { ...elementOptions };\n\n    const rootComponent = createComponentInstance(\n      createElementFn,\n      processedOptions,\n    );\n    layout.element = rootComponent;\n    if (elementDef.name) layout[elementDef.name] = rootComponent;\n\n    // Process children\n    if (elementDef.children) {\n      const rootElement = isComponent(rootComponent)\n        ? rootComponent.element\n        : rootComponent;\n      const childResult = processObjectSchema(\n        elementDef.children,\n        rootElement,\n        options,\n      );\n      Object.assign(layout, childResult.layout);\n    }\n\n    return createLayoutResult(layout);\n  }\n\n  // Process normal schema elements\n  const fragment = parentElement ? createFragment() : null;\n\n  for (const key in schema as Record<string, any>) {\n    const def = (schema as Record<string, any>)[key];\n    if (!def) continue;\n\n    const elementCreator = def.creator || defaultCreator;\n    const elementOptions = def.options || {};\n    const shouldApplyPrefix =\n      \"prefix\" in elementOptions\n        ? elementOptions.prefix\n        : options.prefix !== false;\n    const processedOptions = shouldApplyPrefix\n      ? processClassNames(elementOptions)\n      : { ...elementOptions };\n\n    if (!def.name && key !== \"element\") {\n      def.name = key;\n    }\n\n    const created = createComponentInstance(elementCreator, processedOptions);\n    layout[key] = created;\n    if (def.name && def.name !== key) layout[def.name] = created;\n\n    const element = isComponent(created) ? created.element : created;\n    if (fragment) fragment.appendChild(element);\n\n    // Process children\n    if (def.children) {\n      const childResult = processObjectSchema(def.children, element, options);\n      Object.assign(layout, childResult.layout);\n    }\n  }\n\n  // Append to parent\n  if (parentElement && fragment) {\n    const parentDom = isComponent(parentElement)\n      ? parentElement.element\n      : parentElement;\n    parentDom.appendChild(fragment);\n    releaseFragment(fragment);\n  }\n\n  return createLayoutResult(layout);\n}\n\n// ============================================================================\n// LAYOUT RESULT CREATION\n// ============================================================================\n\n/**\n * Flattens a nested layout into a simple object with element and component references\n */\nfunction flattenLayout(layout: Record<string, any>): Record<string, any> {\n  const flattened: Record<string, any> = {};\n\n  if (!layout || typeof layout !== \"object\") return flattened;\n\n  for (const key in layout) {\n    const value = layout[key];\n    if (\n      value &&\n      typeof value !== \"function\" &&\n      (value instanceof HTMLElement ||\n        (typeof SVGElement !== \"undefined\" && value instanceof SVGElement) ||\n        isComponent(value))\n    ) {\n      flattened[key] = value;\n    }\n  }\n\n  return flattened;\n}\n\n/**\n * Creates a layout result object with utility functions\n */\nfunction createLayoutResult(layout: Record<string, any>): LayoutResult {\n  const flattenedComponents = flattenLayout(layout);\n\n  return {\n    layout,\n    element: layout.element,\n    component: flattenedComponents,\n\n    get(name: string): any {\n      return layout[name] ?? null;\n    },\n\n    getAll(): Record<string, any> {\n      return flattenedComponents;\n    },\n\n    destroy(): void {\n      // Track destroyed components to avoid double-destroy\n      const destroyed = new Set<any>();\n\n      // Helper to safely destroy a component\n      const destroyComponent = (component: any): void => {\n        if (!component || destroyed.has(component)) return;\n\n        // Skip plain HTML elements and non-objects\n        if (component instanceof HTMLElement || typeof component !== \"object\")\n          return;\n\n        // Check if it's a component with destroy method\n        if (typeof component.destroy === \"function\") {\n          destroyed.add(component);\n          try {\n            component.destroy();\n          } catch (e) {\n            // Ignore destroy errors - component may already be cleaned up\n          }\n        }\n      };\n\n      // First destroy components from the components array (if present)\n      // This ensures all named components are destroyed even if nested\n      if (Array.isArray(layout.components)) {\n        for (const [name, component] of layout.components) {\n          destroyComponent(component);\n        }\n      }\n\n      // Then iterate over all layout keys for any missed components\n      for (const key in layout) {\n        if (key === \"element\" || key === \"components\") continue;\n        destroyComponent(layout[key]);\n      }\n\n      // Clear the components array\n      if (Array.isArray(layout.components)) {\n        layout.components.length = 0;\n      }\n\n      // Remove root element from DOM\n      if (layout.element) {\n        const element = isComponent(layout.element)\n          ? layout.element.element\n          : layout.element;\n        if (element && element.parentNode) {\n          element.parentNode.removeChild(element);\n        }\n      }\n\n      // Clear references to help GC\n      for (const key in layout) {\n        delete layout[key];\n      }\n    },\n  };\n}\n\n// ============================================================================\n// UNIFIED ENTRY POINT\n// ============================================================================\n\n/**\n * Creates a layout from various schema formats\n * Unified processor for arrays, objects, JSX, and HTML strings\n */\nexport function createLayout(\n  schema: any,\n  parentElement: HTMLElement | null = null,\n  options: LayoutOptions = {},\n): LayoutResult {\n  // Handle function schemas\n  if (typeof schema === \"function\") {\n    schema = schema();\n  }\n\n  // Handle HTML string schemas\n  if (typeof schema === \"string\") {\n    const template = document.createElement(\"template\");\n    template.innerHTML = schema.trim();\n    const fragment = template.content;\n\n    if (parentElement && fragment.hasChildNodes()) {\n      parentElement.appendChild(fragment);\n    }\n\n    const layout = { element: fragment.firstElementChild as HTMLElement };\n    return createLayoutResult(layout);\n  }\n\n  // Handle JSX-like schemas (array with function, string, object pattern)\n  if (\n    Array.isArray(schema) &&\n    schema.length >= 3 &&\n    typeof schema[0] === \"function\" &&\n    typeof schema[1] === \"string\" &&\n    isObject(schema[2])\n  ) {\n    return processArraySchema(schema, parentElement, 0, options);\n  }\n\n  // Route to appropriate processor\n  return Array.isArray(schema)\n    ? processArraySchema(schema, parentElement, 0, options)\n    : processObjectSchema(schema, parentElement, options);\n}\n\n// ============================================================================\n// EXPORTS\n// ============================================================================\n\n// Clear functions for the unified system\nexport function clearClassCache(): void {\n  classCache.clear();\n}\n\nexport function clearFragmentPool(): void {\n  fragmentPool.clear();\n}\n\nexport {\n  processClassNames,\n  isComponent,\n  flattenLayout,\n  applyLayoutClasses,\n  applyLayoutItemClasses,\n  createLayoutResult,\n};\n",
    "/**\n * @module core/layout/config\n * @description Essential layout configuration utilities\n * Core functionality is integrated into schema.ts for better performance\n */\n\n// Configuration constants\nconst PREFIX = \"mtrl\"; // TODO: Make this configurable from main mtrl config\nconst PREFIX_WITH_DASH = `${PREFIX}-`;\n\n/**\n * Simple DOM utilities\n */\nfunction addClass(element: any, className: string): void {\n  if (element && className && element.classList) {\n    element.classList.add(className);\n  }\n}\n\nfunction hasClass(element: any, className: string): boolean {\n  return element && element.classList && element.classList.contains(className);\n}\n\n/**\n * Helper function to clean up previous layout classes from an element\n * Useful for dynamic class management\n *\n * @param element - Element to clean layout classes from\n */\nexport function cleanupLayoutClasses(element: any): void {\n  if (!element || !element.classList) return;\n\n  // Get all classes from the element\n  const classList = Array.from(element.classList) as string[];\n\n  // Find and remove layout-related classes\n  const layoutClasses = classList.filter(\n    (cls: string) =>\n      cls.startsWith(`${PREFIX_WITH_DASH}layout--`) ||\n      cls.includes(`-${PREFIX_WITH_DASH}layout--`)\n  );\n\n  // Remove each layout class\n  layoutClasses.forEach((cls: string) => {\n    element.classList.remove(cls);\n  });\n}\n\n/**\n * Helper function to get the layout type from element classes\n *\n * @param element - Element to check\n * @returns Layout type if found, empty string otherwise\n */\nexport function getLayoutType(element: any): string {\n  return hasClass(element, `${PREFIX_WITH_DASH}layout--stack`)\n    ? \"stack\"\n    : hasClass(element, `${PREFIX_WITH_DASH}layout--row`)\n    ? \"row\"\n    : hasClass(element, `${PREFIX_WITH_DASH}layout--grid`)\n    ? \"grid\"\n    : \"\";\n}\n\n/**\n * Gets the configured prefix for the layout system\n * @returns Current prefix with dash\n */\nexport function getLayoutPrefix(): string {\n  return PREFIX_WITH_DASH;\n}\n\n/**\n * Sets layout classes on an element dynamically\n * Useful for programmatic layout updates\n *\n * @param element - Target element\n * @param layoutType - Layout type to apply\n * @param classes - Additional classes to apply\n */\nexport function setLayoutClasses(\n  element: any,\n  layoutType: string,\n  classes: string[] = []\n): void {\n  if (!element || !layoutType) return;\n\n  // Clean up existing layout classes first\n  cleanupLayoutClasses(element);\n\n  // Apply base layout type\n  addClass(element, `${PREFIX_WITH_DASH}layout--${layoutType}`);\n\n  // Apply additional classes\n  classes.forEach((cls) => {\n    if (cls.startsWith(\"layout--\") || cls.startsWith(\"layout__\")) {\n      addClass(element, `${PREFIX_WITH_DASH}${cls}`);\n    } else {\n      addClass(element, cls);\n    }\n  });\n}\n",
    "/**\n * @module core/layout/jsx\n * @description JSX-like syntax support for layout creation\n * Provides a simple h() function for creating elements without React dependency\n */\n\nimport type { LayoutResult } from \"./types\";\nimport { createLayout } from \"./schema\";\n\n/**\n * Fragment symbol for JSX fragments\n */\nexport const Fragment = Symbol(\"Fragment\");\n\n/**\n * JSX-like hyperscript function\n * Creates elements in a React-like syntax without React dependency\n *\n * @param tag - HTML tag name, component function, or Fragment\n * @param props - Element properties and attributes\n * @param children - Child elements\n * @returns DOM element or component\n */\nexport function h(\n  tag: string | Function | typeof Fragment,\n  props?: Record<string, any> | null,\n  ...children: any[]\n): any {\n  // Handle Fragment\n  if (tag === Fragment) {\n    const fragment = document.createDocumentFragment();\n    children.forEach((child) => {\n      if (child != null) {\n        const element =\n          typeof child === \"string\" ? document.createTextNode(child) : child;\n        fragment.appendChild(element);\n      }\n    });\n    return fragment;\n  }\n\n  // Handle string tags (HTML elements)\n  if (typeof tag === \"string\") {\n    const element = document.createElement(tag);\n\n    // Apply props\n    if (props) {\n      for (const [key, value] of Object.entries(props)) {\n        if (key === \"className\" || key === \"class\") {\n          element.className = value;\n        } else if (key.startsWith(\"on\") && typeof value === \"function\") {\n          // Event handler\n          const eventName = key.slice(2).toLowerCase();\n          element.addEventListener(eventName, value);\n        } else if (key === \"style\" && typeof value === \"object\") {\n          // Style object\n          Object.assign(element.style, value);\n        } else if (key === \"dangerouslySetInnerHTML\") {\n          // HTML content\n          element.innerHTML = value.__html || \"\";\n        } else if (value != null) {\n          // Regular attribute\n          element.setAttribute(key, value.toString());\n        }\n      }\n    }\n\n    // Append children\n    children.forEach((child) => {\n      if (child != null) {\n        if (typeof child === \"string\") {\n          element.appendChild(document.createTextNode(child));\n        } else if (child instanceof Node) {\n          element.appendChild(child);\n        } else {\n          element.appendChild(document.createTextNode(String(child)));\n        }\n      }\n    });\n\n    return element;\n  }\n\n  // Handle component functions\n  if (typeof tag === \"function\") {\n    const allProps = props || {};\n    if (children.length > 0) {\n      allProps.children = children;\n    }\n    return tag(allProps);\n  }\n\n  // Fallback to div\n  return h(\"div\", props, ...children);\n}\n\n/**\n * Creates a layout using JSX-like syntax\n * Provides a bridge between JSX and the layout system\n *\n * @param jsxElement - JSX element created with h()\n * @param parentElement - Parent element to attach to\n * @returns Layout result\n */\nexport function createJsxLayout(\n  jsxElement: any,\n  parentElement?: any\n): LayoutResult {\n  // Convert JSX element to layout schema\n  const schema = jsxElement;\n\n  // Create layout using the standard createLayout function\n  return createLayout(schema, parentElement);\n}\n\n/**\n * Utility to create a simple component from a function\n * Useful for creating reusable JSX components\n *\n * @param fn - Component function\n * @returns Component that can be used in JSX\n */\nexport function component(fn: (props: Record<string, any>) => any): Function {\n  return function (props: Record<string, any>): any {\n    return fn(props || {});\n  };\n}\n\n/**\n * Utility to render multiple JSX elements\n * Useful for creating lists or collections\n *\n * @param elements - Array of JSX elements\n * @param parentElement - Parent element to attach to\n * @returns Array of layout results\n */\nexport function renderElements(\n  elements: any[],\n  parentElement?: any\n): LayoutResult[] {\n  return elements.map((element) => createJsxLayout(element, parentElement));\n}\n\n/**\n * Common JSX element creators for convenience\n */\nexport const jsx = {\n  div: (props?: Record<string, any>, ...children: any[]) =>\n    h(\"div\", props, ...children),\n  span: (props?: Record<string, any>, ...children: any[]) =>\n    h(\"span\", props, ...children),\n  p: (props?: Record<string, any>, ...children: any[]) =>\n    h(\"p\", props, ...children),\n  button: (props?: Record<string, any>, ...children: any[]) =>\n    h(\"button\", props, ...children),\n  input: (props?: Record<string, any>) => h(\"input\", props),\n  img: (props?: Record<string, any>) => h(\"img\", props),\n  a: (props?: Record<string, any>, ...children: any[]) =>\n    h(\"a\", props, ...children),\n  ul: (props?: Record<string, any>, ...children: any[]) =>\n    h(\"ul\", props, ...children),\n  li: (props?: Record<string, any>, ...children: any[]) =>\n    h(\"li\", props, ...children),\n  section: (props?: Record<string, any>, ...children: any[]) =>\n    h(\"section\", props, ...children),\n  header: (props?: Record<string, any>, ...children: any[]) =>\n    h(\"header\", props, ...children),\n  footer: (props?: Record<string, any>, ...children: any[]) =>\n    h(\"footer\", props, ...children),\n  main: (props?: Record<string, any>, ...children: any[]) =>\n    h(\"main\", props, ...children),\n  article: (props?: Record<string, any>, ...children: any[]) =>\n    h(\"article\", props, ...children),\n};\n",
    "/**\n * @module core/layout\n * @description Unified layout system for mtrl-addons\n * Provides array, object, and JSX-based layout creation with integrated optimizations\n */\n\n// Import for use in convenience functions\nimport { createLayout, clearClassCache, clearFragmentPool } from \"./schema\";\n\n// Core schema processor and utilities\nexport {\n  createLayout,\n  processClassNames,\n  isComponent,\n  flattenLayout,\n  applyLayoutClasses,\n  applyLayoutItemClasses,\n  createLayoutResult,\n  clearClassCache,\n  clearFragmentPool,\n} from \"./schema\";\n\n// Essential types\nexport type {\n  LayoutConfig,\n  LayoutItemConfig,\n  LayoutOptions,\n  LayoutResult,\n  ComponentLike,\n  ElementOptions,\n  ElementDefinition,\n  Schema,\n} from \"./types\";\n\n// Configuration utilities\nexport {\n  cleanupLayoutClasses,\n  getLayoutType,\n  getLayoutPrefix,\n  setLayoutClasses,\n} from \"./config\";\n\n// JSX support\nexport {\n  h,\n  Fragment,\n  createJsxLayout,\n  component,\n  renderElements,\n  jsx,\n} from \"./jsx\";\n\n// Default export for convenient usage\nexport { createLayout as default } from \"./schema\";\n\n/**\n * Convenience function to create a layout with common patterns\n * Provides a simpler API for common use cases\n */\nexport function layout(\n  type: \"stack\" | \"row\" | \"grid\" | \"flex\" = \"stack\",\n  options: Record<string, any> = {}\n): any {\n  return createLayout([\n    \"div\",\n    {\n      layout: { type },\n      ...options,\n    },\n  ]);\n}\n\n/**\n * Creates a responsive grid layout\n * Automatically handles responsive breakpoints\n */\nexport function grid(\n  columns: number | \"auto-fit\" | \"auto-fill\" = \"auto-fit\",\n  options: Record<string, any> = {}\n): any {\n  return createLayout([\n    \"div\",\n    {\n      layout: {\n        type: \"grid\",\n        columns,\n        gap: options.gap || \"1rem\",\n        ...options.layout,\n      },\n      ...options,\n    },\n  ]);\n}\n\n/**\n * Creates a flexible row layout\n * Automatically handles mobile stacking\n */\nexport function row(options: Record<string, any> = {}): any {\n  return createLayout([\n    \"div\",\n    {\n      layout: {\n        type: \"row\",\n        gap: options.gap || \"1rem\",\n        mobileStack: options.mobileStack !== false,\n        ...options.layout,\n      },\n      ...options,\n    },\n  ]);\n}\n\n/**\n * Creates a vertical stack layout\n * Default layout type with consistent spacing\n */\nexport function stack(options: Record<string, any> = {}): any {\n  return createLayout([\n    \"div\",\n    {\n      layout: {\n        type: \"stack\",\n        gap: options.gap || \"1rem\",\n        ...options.layout,\n      },\n      ...options,\n    },\n  ]);\n}\n\n/**\n * Creates a layout from a template function\n * Useful for dynamic layouts\n */\nexport function template(\n  fn: (props: Record<string, any>) => any,\n  props: Record<string, any> = {}\n): any {\n  const schema = fn(props);\n  return createLayout(schema);\n}\n\n/**\n * Performance utilities for layout management\n */\nexport const performance = {\n  clearCache: clearClassCache,\n  clearFragmentPool,\n\n  /**\n   * Clears all cached resources\n   */\n  clearAll(): void {\n    clearClassCache();\n    clearFragmentPool();\n  },\n\n  /**\n   * Gets current cache stats\n   */\n  getStats(): Record<string, any> {\n    return {\n      // Stats would be implemented in the actual cache system\n      message: \"Performance stats available in browser console\",\n    };\n  },\n};\n"
  ],
  "mappings": "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",
  "debugId": "8F4403D255F8A70864756E2164756E21",
  "names": []
}