@hyperfixi/behaviors 2.0.0

package/dist/index.cjs

@@ -0,0 +1,907 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/schemas/draggable.schema.ts
+var draggableSchema;
+var init_draggable_schema = __esm({
+  "src/schemas/draggable.schema.ts"() {
+    "use strict";
+    draggableSchema = {
+      name: "Draggable",
+      category: "ui",
+      tier: "core",
+      version: "1.0.0",
+      description: "Makes elements draggable with pointer events",
+      parameters: [
+        {
+          name: "dragHandle",
+          type: "selector",
+          optional: true,
+          default: "me",
+          description: "CSS selector for the drag handle element"
+        }
+      ],
+      events: [
+        { name: "draggable:start", description: "Fired when drag begins" },
+        { name: "draggable:move", description: "Fired during each movement" },
+        { name: "draggable:end", description: "Fired when drag completes" }
+      ],
+      requirements: ["position: absolute or position: fixed on the element"],
+      source: `
+behavior Draggable(dragHandle)
+  init
+    if no dragHandle set dragHandle to me
+  end
+  on pointerdown(clientX, clientY) from dragHandle
+    halt the event
+    trigger draggable:start
+    measure x
+    set startX to it
+    measure y
+    set startY to it
+    set xoff to clientX - startX
+    set yoff to clientY - startY
+    repeat until event pointerup from document
+      wait for pointermove(clientX, clientY) or
+               pointerup(clientX, clientY) from document
+      add { left: \${clientX - xoff}px; top: \${clientY - yoff}px; }
+      trigger draggable:move
+    end
+    trigger draggable:end
+  end
+end
+`.trim()
+    };
+  }
+});
+
+// src/behaviors/draggable.ts
+var draggable_exports = {};
+__export(draggable_exports, {
+  default: () => draggable_default,
+  draggableMetadata: () => draggableMetadata,
+  draggableSource: () => draggableSource,
+  registerDraggable: () => registerDraggable
+});
+async function registerDraggable(hyperfixi) {
+  const hf = hyperfixi || (typeof window !== "undefined" ? window.lokascript : null);
+  if (!hf) {
+    throw new Error(
+      "LokaScript not found. Make sure @hyperfixi/core is loaded before registering behaviors."
+    );
+  }
+  const result = hf.compileSync(draggableSchema.source, { traditional: true });
+  if (!result.ok) {
+    throw new Error(`Failed to compile Draggable behavior: ${JSON.stringify(result.errors)}`);
+  }
+  const ctx = hf.createContext ? hf.createContext() : { locals: /* @__PURE__ */ new Map(), globals: /* @__PURE__ */ new Map() };
+  await hf.execute(result.ast, ctx);
+}
+var draggableSource, draggableMetadata, draggable_default;
+var init_draggable = __esm({
+  "src/behaviors/draggable.ts"() {
+    "use strict";
+    init_draggable_schema();
+    draggableSource = draggableSchema.source;
+    draggableMetadata = draggableSchema;
+    if (typeof window !== "undefined" && window.lokascript) {
+      registerDraggable().catch(console.error);
+    }
+    draggable_default = {
+      source: draggableSchema.source,
+      metadata: draggableSchema,
+      register: registerDraggable
+    };
+  }
+});
+
+// src/schemas/removable.schema.ts
+var removableSchema;
+var init_removable_schema = __esm({
+  "src/schemas/removable.schema.ts"() {
+    "use strict";
+    removableSchema = {
+      name: "Removable",
+      category: "data",
+      tier: "common",
+      version: "1.2.0",
+      description: "Makes elements removable on click",
+      parameters: [
+        {
+          name: "triggerEl",
+          type: "selector",
+          optional: true,
+          default: "me",
+          description: "Element that triggers removal (e.g., a close button)"
+        },
+        {
+          name: "confirm",
+          type: "boolean",
+          optional: true,
+          default: false,
+          description: "Show confirmation dialog before removal"
+        },
+        {
+          name: "effect",
+          type: "string",
+          optional: true,
+          default: "none",
+          enum: ["fade", "none"],
+          description: 'Transition effect: "fade" or "none"'
+        }
+      ],
+      events: [
+        { name: "removable:before", description: "Fired before removal (cancelable)" },
+        { name: "removable:removed", description: "Fired after removal" }
+      ],
+      source: `
+behavior Removable(triggerEl, confirm, effect)
+  init
+    if triggerEl is undefined
+      set triggerEl to me
+    end
+  end
+  on click from triggerEl
+    if confirm
+      if not window.confirm("Are you sure?")
+        halt
+      end
+    end
+    trigger removable:before
+    if effect is "fade"
+      transition opacity to 0 over 300ms
+    end
+    trigger removable:removed
+    remove me
+  end
+end
+`.trim()
+    };
+  }
+});
+
+// src/behaviors/removable.ts
+var removable_exports = {};
+__export(removable_exports, {
+  default: () => removable_default,
+  registerRemovable: () => registerRemovable,
+  removableMetadata: () => removableMetadata,
+  removableSource: () => removableSource
+});
+async function registerRemovable(hyperfixi) {
+  const hf = hyperfixi || (typeof window !== "undefined" ? window.lokascript : null);
+  if (!hf) {
+    throw new Error(
+      "LokaScript not found. Make sure @hyperfixi/core is loaded before registering behaviors."
+    );
+  }
+  const result = hf.compileSync(removableSchema.source, { traditional: true });
+  if (!result.ok) {
+    throw new Error(`Failed to compile Removable behavior: ${JSON.stringify(result.errors)}`);
+  }
+  const ctx = hf.createContext ? hf.createContext() : { locals: /* @__PURE__ */ new Map(), globals: /* @__PURE__ */ new Map() };
+  await hf.execute(result.ast, ctx);
+}
+var removableSource, removableMetadata, removable_default;
+var init_removable = __esm({
+  "src/behaviors/removable.ts"() {
+    "use strict";
+    init_removable_schema();
+    removableSource = removableSchema.source;
+    removableMetadata = removableSchema;
+    if (typeof window !== "undefined" && window.lokascript) {
+      registerRemovable().catch(console.error);
+    }
+    removable_default = {
+      source: removableSchema.source,
+      metadata: removableSchema,
+      register: registerRemovable
+    };
+  }
+});
+
+// src/schemas/toggleable.schema.ts
+var toggleableSchema;
+var init_toggleable_schema = __esm({
+  "src/schemas/toggleable.schema.ts"() {
+    "use strict";
+    toggleableSchema = {
+      name: "Toggleable",
+      category: "form",
+      tier: "core",
+      version: "1.0.0",
+      description: "Toggles a CSS class on click",
+      parameters: [
+        {
+          name: "cls",
+          type: "string",
+          optional: true,
+          default: "active",
+          description: "CSS class to toggle"
+        },
+        {
+          name: "target",
+          type: "selector",
+          optional: true,
+          default: "me",
+          description: "Element to toggle the class on"
+        }
+      ],
+      events: [
+        { name: "toggleable:on", description: "Fired when class is added" },
+        { name: "toggleable:off", description: "Fired when class is removed" }
+      ],
+      source: `
+behavior Toggleable(cls, target)
+  init
+    if cls is undefined
+      set cls to "active"
+    end
+    if target is undefined
+      set target to me
+    end
+  end
+  on click
+    toggle .{cls} on target
+  end
+end
+`.trim()
+    };
+  }
+});
+
+// src/behaviors/toggleable.ts
+var toggleable_exports = {};
+__export(toggleable_exports, {
+  default: () => toggleable_default,
+  registerToggleable: () => registerToggleable,
+  toggleableMetadata: () => toggleableMetadata,
+  toggleableSource: () => toggleableSource
+});
+async function registerToggleable(hyperfixi) {
+  const hf = hyperfixi || (typeof window !== "undefined" ? window.lokascript : null);
+  if (!hf) {
+    throw new Error(
+      "LokaScript not found. Make sure @hyperfixi/core is loaded before registering behaviors."
+    );
+  }
+  const result = hf.compileSync(toggleableSchema.source, { traditional: true });
+  if (!result.ok) {
+    throw new Error(`Failed to compile Toggleable behavior: ${JSON.stringify(result.errors)}`);
+  }
+  const ctx = hf.createContext ? hf.createContext() : { locals: /* @__PURE__ */ new Map(), globals: /* @__PURE__ */ new Map() };
+  await hf.execute(result.ast, ctx);
+}
+var toggleableSource, toggleableMetadata, toggleable_default;
+var init_toggleable = __esm({
+  "src/behaviors/toggleable.ts"() {
+    "use strict";
+    init_toggleable_schema();
+    toggleableSource = toggleableSchema.source;
+    toggleableMetadata = toggleableSchema;
+    if (typeof window !== "undefined" && window.lokascript) {
+      registerToggleable().catch(console.error);
+    }
+    toggleable_default = {
+      source: toggleableSchema.source,
+      metadata: toggleableSchema,
+      register: registerToggleable
+    };
+  }
+});
+
+// src/schemas/sortable.schema.ts
+var sortableSchema;
+var init_sortable_schema = __esm({
+  "src/schemas/sortable.schema.ts"() {
+    "use strict";
+    sortableSchema = {
+      name: "Sortable",
+      category: "ui",
+      tier: "common",
+      version: "1.0.0",
+      description: "Makes child elements reorderable via drag-and-drop",
+      parameters: [
+        {
+          name: "handle",
+          type: "selector",
+          optional: true,
+          default: "none",
+          description: "CSS selector for drag handles within items"
+        },
+        {
+          name: "dragClass",
+          type: "string",
+          optional: true,
+          default: "sorting",
+          description: "CSS class added to item during drag"
+        }
+      ],
+      events: [
+        { name: "sortable:start", description: "Fired when drag begins" },
+        {
+          name: "sortable:move",
+          description: "Fired during drag \u2014 handle this event to reorder DOM elements"
+        },
+        { name: "sortable:end", description: "Fired when drag completes" }
+      ],
+      requirements: ["Users must handle DOM reordering in sortable:move event handlers"],
+      source: `
+behavior Sortable(handle, dragClass)
+  init
+    if no dragClass set dragClass to "sorting"
+  end
+  on pointerdown(target, clientY) from me
+    set item to closest <li/> in target
+    if no item exit
+    if handle
+      set handleEl to target.closest(handle)
+      if no handleEl exit
+    end
+    halt the event
+    add dragClass to item
+    trigger sortable:start on me
+    repeat until event pointerup from document
+      wait for pointermove(clientY) from document
+      trigger sortable:move on me
+    end
+    remove dragClass from item
+    trigger sortable:end on me
+  end
+end
+`.trim()
+    };
+  }
+});
+
+// src/behaviors/sortable.ts
+var sortable_exports = {};
+__export(sortable_exports, {
+  default: () => sortable_default,
+  registerSortable: () => registerSortable,
+  sortableMetadata: () => sortableMetadata,
+  sortableSource: () => sortableSource
+});
+async function registerSortable(hyperfixi) {
+  const hf = hyperfixi || (typeof window !== "undefined" ? window.lokascript : null);
+  if (!hf) {
+    throw new Error(
+      "LokaScript not found. Make sure @hyperfixi/core is loaded before registering behaviors."
+    );
+  }
+  const result = hf.compileSync(sortableSchema.source, { traditional: true });
+  if (!result.ok) {
+    throw new Error(`Failed to compile Sortable behavior: ${JSON.stringify(result.errors)}`);
+  }
+  const ctx = hf.createContext ? hf.createContext() : { locals: /* @__PURE__ */ new Map(), globals: /* @__PURE__ */ new Map() };
+  await hf.execute(result.ast, ctx);
+}
+var sortableSource, sortableMetadata, sortable_default;
+var init_sortable = __esm({
+  "src/behaviors/sortable.ts"() {
+    "use strict";
+    init_sortable_schema();
+    sortableSource = sortableSchema.source;
+    sortableMetadata = sortableSchema;
+    if (typeof window !== "undefined" && window.lokascript) {
+      registerSortable().catch(console.error);
+    }
+    sortable_default = {
+      source: sortableSchema.source,
+      metadata: sortableSchema,
+      register: registerSortable
+    };
+  }
+});
+
+// src/schemas/resizable.schema.ts
+var resizableSchema;
+var init_resizable_schema = __esm({
+  "src/schemas/resizable.schema.ts"() {
+    "use strict";
+    resizableSchema = {
+      name: "Resizable",
+      category: "ui",
+      tier: "optional",
+      version: "1.0.0",
+      description: "Makes elements resizable by dragging",
+      parameters: [
+        {
+          name: "handle",
+          type: "selector",
+          optional: true,
+          default: "me",
+          description: "CSS selector for the resize handle (defaults to the element itself)"
+        },
+        {
+          name: "minWidth",
+          type: "number",
+          optional: true,
+          default: 50,
+          description: "Minimum width in pixels"
+        },
+        {
+          name: "minHeight",
+          type: "number",
+          optional: true,
+          default: 50,
+          description: "Minimum height in pixels"
+        },
+        {
+          name: "maxWidth",
+          type: "number",
+          optional: true,
+          default: 9999,
+          description: "Maximum width in pixels"
+        },
+        {
+          name: "maxHeight",
+          type: "number",
+          optional: true,
+          default: 9999,
+          description: "Maximum height in pixels"
+        }
+      ],
+      events: [
+        { name: "resizable:start", description: "Fired when resize begins" },
+        { name: "resizable:resize", description: "Fired during resize" },
+        { name: "resizable:end", description: "Fired when resize completes" }
+      ],
+      source: `
+behavior Resizable(handle, minWidth, minHeight, maxWidth, maxHeight)
+  init
+    if no handle set handle to me
+    if no minWidth set minWidth to 50
+    if no minHeight set minHeight to 50
+    if no maxWidth set maxWidth to 9999
+    if no maxHeight set maxHeight to 9999
+  end
+  on pointerdown(clientX, clientY) from handle
+    halt the event
+    trigger resizable:start
+    measure width
+    set startWidth to it
+    measure height
+    set startHeight to it
+    set startX to clientX
+    set startY to clientY
+    repeat until event pointerup from document
+      wait for pointermove(clientX, clientY) or
+               pointerup from document
+      set newWidth to startWidth + (clientX - startX)
+      set newHeight to startHeight + (clientY - startY)
+      if newWidth < minWidth set newWidth to minWidth
+      if newWidth > maxWidth set newWidth to maxWidth
+      if newHeight < minHeight set newHeight to minHeight
+      if newHeight > maxHeight set newHeight to maxHeight
+      add { width: \${newWidth}px; height: \${newHeight}px; }
+      trigger resizable:resize
+    end
+    trigger resizable:end
+  end
+end
+`.trim()
+    };
+  }
+});
+
+// src/behaviors/resizable.ts
+var resizable_exports = {};
+__export(resizable_exports, {
+  default: () => resizable_default,
+  registerResizable: () => registerResizable,
+  resizableMetadata: () => resizableMetadata,
+  resizableSource: () => resizableSource
+});
+async function registerResizable(hyperfixi) {
+  const hf = hyperfixi || (typeof window !== "undefined" ? window.lokascript : null);
+  if (!hf) {
+    throw new Error(
+      "LokaScript not found. Make sure @hyperfixi/core is loaded before registering behaviors."
+    );
+  }
+  const result = hf.compileSync(resizableSchema.source, { traditional: true });
+  if (!result.ok) {
+    throw new Error(`Failed to compile Resizable behavior: ${JSON.stringify(result.errors)}`);
+  }
+  const ctx = hf.createContext ? hf.createContext() : { locals: /* @__PURE__ */ new Map(), globals: /* @__PURE__ */ new Map() };
+  await hf.execute(result.ast, ctx);
+}
+var resizableSource, resizableMetadata, resizable_default;
+var init_resizable = __esm({
+  "src/behaviors/resizable.ts"() {
+    "use strict";
+    init_resizable_schema();
+    resizableSource = resizableSchema.source;
+    resizableMetadata = resizableSchema;
+    if (typeof window !== "undefined" && window.lokascript) {
+      registerResizable().catch(console.error);
+    }
+    resizable_default = {
+      source: resizableSchema.source,
+      metadata: resizableSchema,
+      register: registerResizable
+    };
+  }
+});
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ALL_BEHAVIOR_NAMES: () => ALL_BEHAVIOR_NAMES,
+  BEHAVIORS_BY_CATEGORY: () => BEHAVIORS_BY_CATEGORY,
+  BEHAVIORS_BY_TIER: () => BEHAVIORS_BY_TIER,
+  BEHAVIOR_CATEGORIES: () => BEHAVIOR_CATEGORIES,
+  BEHAVIOR_TIERS: () => BEHAVIOR_TIERS,
+  Draggable: () => draggable_default,
+  Removable: () => removable_default,
+  Resizable: () => resizable_default,
+  Sortable: () => sortable_default,
+  Toggleable: () => toggleable_default,
+  draggableMetadata: () => draggableMetadata,
+  draggableSource: () => draggableSource,
+  getAllSchemas: () => getAllSchemas,
+  getAllSchemasRecord: () => getAllSchemasRecord,
+  getAvailableBehaviors: () => getAvailableBehaviors,
+  getBehavior: () => getBehavior,
+  getBehaviorsByCategory: () => getBehaviorsByCategory,
+  getBehaviorsByTier: () => getBehaviorsByTier,
+  getRegisteredBehaviors: () => getRegisteredBehaviors,
+  getSchema: () => getSchema,
+  hasLoader: () => hasLoader,
+  isRegistered: () => isRegistered,
+  loadAll: () => loadAll,
+  loadBehavior: () => loadBehavior,
+  preloadCategory: () => preloadCategory,
+  preloadTier: () => preloadTier,
+  ready: () => ready,
+  registerAll: () => registerAll,
+  registerAllWithRuntime: () => registerAllWithRuntime,
+  registerBehavior: () => registerBehavior,
+  registerDraggable: () => registerDraggable,
+  registerLoader: () => registerLoader,
+  registerRemovable: () => registerRemovable,
+  registerResizable: () => registerResizable,
+  registerSchema: () => registerSchema,
+  registerSortable: () => registerSortable,
+  registerToggleable: () => registerToggleable,
+  registerWithRuntime: () => registerWithRuntime,
+  removableMetadata: () => removableMetadata,
+  removableSource: () => removableSource,
+  resizableMetadata: () => resizableMetadata,
+  resizableSource: () => resizableSource,
+  sortableMetadata: () => sortableMetadata,
+  sortableSource: () => sortableSource,
+  toggleableMetadata: () => toggleableMetadata,
+  toggleableSource: () => toggleableSource,
+  tryGetBehavior: () => tryGetBehavior,
+  tryGetSchema: () => tryGetSchema
+});
+module.exports = __toCommonJS(index_exports);
+init_draggable();
+init_removable();
+init_toggleable();
+init_sortable();
+init_resizable();
+
+// src/registry.ts
+var behaviors = /* @__PURE__ */ new Map();
+var schemas = /* @__PURE__ */ new Map();
+var loaders = /* @__PURE__ */ new Map();
+var loadingPromises = /* @__PURE__ */ new Map();
+function registerBehavior(name, module2) {
+  behaviors.set(name, module2);
+  if (module2.metadata) {
+    schemas.set(name, module2.metadata);
+  }
+}
+function registerSchema(schema) {
+  schemas.set(schema.name, schema);
+}
+function registerLoader(name, loader) {
+  loaders.set(name, loader);
+}
+function getBehavior(name) {
+  const behavior = behaviors.get(name);
+  if (!behavior) {
+    const registered = Array.from(behaviors.keys()).join(", ");
+    throw new Error(
+      `Behavior '${name}' is not registered. Registered behaviors: ${registered || "none"}. Use loadBehavior('${name}') to lazy load it.`
+    );
+  }
+  return behavior;
+}
+function tryGetBehavior(name) {
+  return behaviors.get(name);
+}
+function getSchema(name) {
+  const schema = schemas.get(name);
+  if (!schema) {
+    throw new Error(
+      `Schema for behavior '${name}' is not registered. Use tryGetSchema('${name}') for a non-throwing alternative.`
+    );
+  }
+  return schema;
+}
+function tryGetSchema(name) {
+  return schemas.get(name);
+}
+function isRegistered(name) {
+  return behaviors.has(name);
+}
+function hasLoader(name) {
+  return loaders.has(name);
+}
+function getRegisteredBehaviors() {
+  return Array.from(behaviors.keys());
+}
+function getAvailableBehaviors() {
+  const names = /* @__PURE__ */ new Set([...behaviors.keys(), ...loaders.keys()]);
+  return Array.from(names);
+}
+function getBehaviorsByCategory(category) {
+  const result = [];
+  for (const [name, schema] of schemas) {
+    if (schema.category === category) {
+      result.push(name);
+    }
+  }
+  return result;
+}
+function getBehaviorsByTier(tier) {
+  const result = [];
+  for (const [name, schema] of schemas) {
+    if (schema.tier === tier) {
+      result.push(name);
+    }
+  }
+  return result;
+}
+function getAllSchemas() {
+  return Array.from(schemas.values());
+}
+function getAllSchemasRecord() {
+  const result = {};
+  for (const [name, schema] of schemas) {
+    result[name] = schema;
+  }
+  return result;
+}
+async function loadBehavior(name) {
+  const cached = behaviors.get(name);
+  if (cached) {
+    return cached;
+  }
+  const inFlight = loadingPromises.get(name);
+  if (inFlight) {
+    return inFlight;
+  }
+  const loader = loaders.get(name);
+  if (!loader) {
+    throw new Error(
+      `No loader registered for behavior '${name}'. Available loaders: ${Array.from(loaders.keys()).join(", ") || "none"}`
+    );
+  }
+  const promise = loader().then((mod) => {
+    const module2 = mod.default;
+    registerBehavior(name, module2);
+    loadingPromises.delete(name);
+    return module2;
+  });
+  loadingPromises.set(name, promise);
+  return promise;
+}
+async function preloadTier(tier) {
+  const names = getBehaviorsByTier(tier);
+  await Promise.all(
+    names.map(
+      (name) => loadBehavior(name).catch((err) => {
+        console.warn(`[behaviors] Failed to preload '${name}' (tier: ${tier}):`, err);
+      })
+    )
+  );
+}
+async function preloadCategory(category) {
+  const names = getBehaviorsByCategory(category);
+  await Promise.all(
+    names.map(
+      (name) => loadBehavior(name).catch((err) => {
+        console.warn(`[behaviors] Failed to preload '${name}' (category: ${category}):`, err);
+      })
+    )
+  );
+}
+async function loadAll() {
+  const names = getAvailableBehaviors();
+  await Promise.all(
+    names.map(
+      (name) => loadBehavior(name).catch((err) => {
+        console.warn(`[behaviors] Failed to load '${name}':`, err);
+      })
+    )
+  );
+}
+async function registerWithRuntime(name, hyperfixi) {
+  const module2 = await loadBehavior(name);
+  await module2.register(hyperfixi);
+}
+async function registerAllWithRuntime(hyperfixi) {
+  const registrations = Array.from(behaviors.values()).map((module2) => module2.register(hyperfixi));
+  await Promise.all(registrations);
+}
+
+// src/loaders.ts
+init_draggable_schema();
+init_sortable_schema();
+init_resizable_schema();
+init_removable_schema();
+init_toggleable_schema();
+registerSchema(draggableSchema);
+registerSchema(sortableSchema);
+registerSchema(resizableSchema);
+registerSchema(removableSchema);
+registerSchema(toggleableSchema);
+registerLoader("Draggable", () => Promise.resolve().then(() => (init_draggable(), draggable_exports)));
+registerLoader("Sortable", () => Promise.resolve().then(() => (init_sortable(), sortable_exports)));
+registerLoader("Resizable", () => Promise.resolve().then(() => (init_resizable(), resizable_exports)));
+registerLoader("Removable", () => Promise.resolve().then(() => (init_removable(), removable_exports)));
+registerLoader("Toggleable", () => Promise.resolve().then(() => (init_toggleable(), toggleable_exports)));
+
+// src/generated/metadata.ts
+var ALL_BEHAVIOR_NAMES = [
+  "Draggable",
+  "Sortable",
+  "Resizable",
+  "Removable",
+  "Toggleable"
+];
+var BEHAVIORS_BY_CATEGORY = {
+  "ui": [
+    "Draggable",
+    "Sortable",
+    "Resizable"
+  ],
+  "data": [
+    "Removable"
+  ],
+  "animation": [],
+  "form": [
+    "Toggleable"
+  ],
+  "layout": []
+};
+var BEHAVIORS_BY_TIER = {
+  "core": [
+    "Draggable",
+    "Toggleable"
+  ],
+  "common": [
+    "Sortable",
+    "Removable"
+  ],
+  "optional": [
+    "Resizable"
+  ]
+};
+var BEHAVIOR_CATEGORIES = {
+  "Draggable": "ui",
+  "Sortable": "ui",
+  "Resizable": "ui",
+  "Removable": "data",
+  "Toggleable": "form"
+};
+var BEHAVIOR_TIERS = {
+  "Draggable": "core",
+  "Sortable": "common",
+  "Resizable": "optional",
+  "Removable": "common",
+  "Toggleable": "core"
+};
+
+// src/index.ts
+init_draggable();
+init_removable();
+init_toggleable();
+init_sortable();
+init_resizable();
+async function registerAll(hyperfixi) {
+  await Promise.all([
+    registerDraggable(hyperfixi),
+    registerRemovable(hyperfixi),
+    registerToggleable(hyperfixi),
+    registerSortable(hyperfixi),
+    registerResizable(hyperfixi)
+  ]);
+}
+var ready = null;
+if (typeof window !== "undefined" && window.lokascript) {
+  const lsWin = window;
+  ready = registerAll();
+  lsWin.__lokascript_behaviors_ready = ready;
+  ready.then(() => {
+    const hyperfixi = lsWin.lokascript;
+    const savedPromise = lsWin.__lokascript_behaviors_ready;
+    delete lsWin.__lokascript_behaviors_ready;
+    if (hyperfixi.attributeProcessor?.scanAndProcessAll) {
+      hyperfixi.attributeProcessor.scanAndProcessAll().finally(() => {
+        lsWin.__lokascript_behaviors_ready = savedPromise;
+      });
+    } else if (hyperfixi.processNode) {
+      hyperfixi.processNode(document);
+      lsWin.__lokascript_behaviors_ready = savedPromise;
+    }
+  }).catch((err) => {
+    console.error("[behaviors] Auto-registration failed:", err);
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ALL_BEHAVIOR_NAMES,
+  BEHAVIORS_BY_CATEGORY,
+  BEHAVIORS_BY_TIER,
+  BEHAVIOR_CATEGORIES,
+  BEHAVIOR_TIERS,
+  Draggable,
+  Removable,
+  Resizable,
+  Sortable,
+  Toggleable,
+  draggableMetadata,
+  draggableSource,
+  getAllSchemas,
+  getAllSchemasRecord,
+  getAvailableBehaviors,
+  getBehavior,
+  getBehaviorsByCategory,
+  getBehaviorsByTier,
+  getRegisteredBehaviors,
+  getSchema,
+  hasLoader,
+  isRegistered,
+  loadAll,
+  loadBehavior,
+  preloadCategory,
+  preloadTier,
+  ready,
+  registerAll,
+  registerAllWithRuntime,
+  registerBehavior,
+  registerDraggable,
+  registerLoader,
+  registerRemovable,
+  registerResizable,
+  registerSchema,
+  registerSortable,
+  registerToggleable,
+  registerWithRuntime,
+  removableMetadata,
+  removableSource,
+  resizableMetadata,
+  resizableSource,
+  sortableMetadata,
+  sortableSource,
+  toggleableMetadata,
+  toggleableSource,
+  tryGetBehavior,
+  tryGetSchema
+});
+//# sourceMappingURL=index.cjs.map