@almadar/shell-web 0.0.0-stage → 1.0.0

package/dist/chunk-P4ZFUQFF.js

@@ -0,0 +1,93 @@
+// src/lib/slot-definitions.ts
+var SLOT_DEFINITIONS = {
+  // -------------------------------------------------------------------------
+  // Inline Slots - Render in place within the component tree
+  // -------------------------------------------------------------------------
+  main: {
+    name: "main",
+    type: "inline"
+  },
+  sidebar: {
+    name: "sidebar",
+    type: "inline"
+  },
+  dock: {
+    name: "dock",
+    type: "portal",
+    portalTarget: "body",
+    zIndex: 850
+  },
+  // -------------------------------------------------------------------------
+  // Portal Slots - Render to document.body via React Portal
+  // -------------------------------------------------------------------------
+  modal: {
+    name: "modal",
+    type: "portal",
+    portalTarget: "body",
+    zIndex: 1e3
+  },
+  drawer: {
+    name: "drawer",
+    type: "portal",
+    portalTarget: "body",
+    zIndex: 900
+  },
+  overlay: {
+    name: "overlay",
+    type: "portal",
+    portalTarget: "body",
+    zIndex: 1100
+  },
+  center: {
+    name: "center",
+    type: "portal",
+    portalTarget: "body",
+    zIndex: 1e3
+  },
+  toast: {
+    name: "toast",
+    type: "portal",
+    portalTarget: "body",
+    zIndex: 1200,
+    notification: true
+  },
+  // -------------------------------------------------------------------------
+  // Game HUD Slots - Portal for game overlay UI
+  // -------------------------------------------------------------------------
+  "hud-top": {
+    name: "hud-top",
+    type: "portal",
+    portalTarget: "body",
+    zIndex: 500
+  },
+  "hud-bottom": {
+    name: "hud-bottom",
+    type: "portal",
+    portalTarget: "body",
+    zIndex: 500
+  },
+  floating: {
+    name: "floating",
+    type: "portal",
+    portalTarget: "body",
+    zIndex: 800
+  }
+};
+function getSlotDefinition(slot) {
+  return SLOT_DEFINITIONS[slot];
+}
+function isPortalSlot(slot) {
+  return SLOT_DEFINITIONS[slot]?.type === "portal";
+}
+function isNotificationSlot(slot) {
+  return SLOT_DEFINITIONS[slot]?.notification === true;
+}
+function getSlotsByType(type) {
+  return Object.entries(SLOT_DEFINITIONS).filter(([, def]) => def?.type === type).map(([name]) => name);
+}
+function getInlineSlots() {
+  return getSlotsByType("inline");
+}
+var ALL_SLOTS = Object.keys(SLOT_DEFINITIONS);
+
+export { ALL_SLOTS, SLOT_DEFINITIONS, getInlineSlots, getSlotDefinition, isNotificationSlot, isPortalSlot };

package/dist/chunk-PCR37T3U.js

@@ -0,0 +1,296 @@
+import { renderUiEntriesOf } from '@almadar/core/patterns';
+import { kernelEvaluator } from '@almadar/core';
+
+var wiresBySchema = /* @__PURE__ */ new WeakMap();
+function traitEventWires(schema) {
+  const cached = wiresBySchema.get(schema);
+  if (cached) return cached;
+  const wires = kernelEvaluator().eventWires(schema);
+  wiresBySchema.set(schema, wires);
+  return wires;
+}
+
+// src/lib/avl-schema-parser.ts
+function getEntity(orbital) {
+  const entity = orbital.entity;
+  if (typeof entity === "string") {
+    return { name: entity, fields: [], persistence: "runtime" };
+  }
+  if ("extends" in entity) {
+    const ec = entity;
+    return {
+      name: ec.name ?? orbital.name,
+      fields: ec.fields ?? [],
+      persistence: ec.persistence ?? "runtime"
+    };
+  }
+  const e = entity;
+  return {
+    name: e.name,
+    fields: e.fields ?? [],
+    persistence: e.persistence ?? "runtime"
+  };
+}
+function getTraits(orbital) {
+  if (!orbital.traits) return [];
+  return orbital.traits.map((t) => {
+    if (typeof t === "string") return { name: t };
+    if ("ref" in t && !("stateMachine" in t)) return { name: t.name ?? t.ref };
+    return t;
+  });
+}
+function getPages(orbital) {
+  if (!orbital.pages) return [];
+  return orbital.pages.map((p) => {
+    if (typeof p === "string") return { name: p, path: `/${p.toLowerCase()}` };
+    if ("ref" in p && !("path" in p)) return { name: p.ref, path: `/${p.ref.toLowerCase()}` };
+    return p;
+  });
+}
+function getStateMachine(trait) {
+  return trait.stateMachine ?? null;
+}
+function getStates(sm) {
+  return sm.states ?? [];
+}
+function getTransitions(sm) {
+  return sm.transitions ?? [];
+}
+function getEvents(sm) {
+  return sm.events ?? [];
+}
+function getEmits(trait) {
+  const emits = trait.emits;
+  if (!emits) return [];
+  return emits.map((e) => e.event ?? "");
+}
+function getListens(trait) {
+  const listens = trait.listens;
+  if (!listens) return [];
+  return listens.map((l) => l.event ?? "");
+}
+function jsonEffects(t) {
+  return t.effects ?? [];
+}
+function parseEffectType(effect) {
+  if (Array.isArray(effect)) {
+    const [type, ...args] = effect;
+    return { type: String(type), args };
+  }
+  return { type: "unknown", args: [] };
+}
+function exprToTree(expr) {
+  if (Array.isArray(expr)) {
+    const [op, ...args] = expr;
+    return {
+      label: String(op),
+      type: "operator",
+      children: args.map((a) => exprToTree(a))
+    };
+  }
+  if (typeof expr === "string") {
+    if (expr.startsWith("@")) {
+      return { label: expr, type: "binding" };
+    }
+    return { label: expr, type: "literal" };
+  }
+  if (expr !== null && typeof expr === "object") {
+    return { label: JSON.stringify(expr), type: "literal" };
+  }
+  return { label: String(expr), type: "literal" };
+}
+function parseApplicationLevel(schema) {
+  const orbitals = [];
+  const crossLinks = [];
+  if (!schema.orbitals || schema.orbitals.length === 0) {
+    return { orbitals: [], crossLinks: [] };
+  }
+  const count = schema.orbitals.length;
+  const cols = Math.ceil(Math.sqrt(count));
+  const rows = Math.ceil(count / cols);
+  const spacing = 200;
+  const gridW = cols * spacing;
+  const gridH = rows * spacing;
+  const originX = (600 - gridW) / 2 + spacing / 2;
+  const originY = (400 - gridH) / 2 + spacing / 2;
+  schema.orbitals.forEach((orbital, i) => {
+    const entity = getEntity(orbital);
+    const traits = getTraits(orbital);
+    const pages = getPages(orbital);
+    orbitals.push({
+      name: orbital.name,
+      entityName: entity.name,
+      fieldCount: entity.fields.length,
+      persistence: entity.persistence,
+      traitNames: traits.map((t) => t.name ?? ""),
+      pageNames: pages.map((p) => p.name ?? ""),
+      position: {
+        x: originX + i % cols * spacing,
+        y: originY + Math.floor(i / cols) * spacing
+      }
+    });
+  });
+  const seenLinks = /* @__PURE__ */ new Set();
+  for (const w of traitEventWires(schema)) {
+    if (w.emitterOrbital === w.listenerOrbital) continue;
+    const key = `${w.emitterOrbital}\u241F${w.listenerOrbital}\u241F${w.event}`;
+    if (seenLinks.has(key)) continue;
+    seenLinks.add(key);
+    crossLinks.push({
+      emitterOrbital: w.emitterOrbital,
+      listenerOrbital: w.listenerOrbital,
+      eventName: w.event,
+      emitterTrait: w.emitterTrait,
+      listenerTrait: w.listenerTrait
+    });
+  }
+  return { orbitals, crossLinks };
+}
+function parseOrbitalLevel(schema, orbitalName) {
+  if (!schema.orbitals) return null;
+  const orbital = schema.orbitals.find((o) => o.name === orbitalName);
+  if (!orbital) return null;
+  const entity = getEntity(orbital);
+  const traits = getTraits(orbital);
+  const pages = getPages(orbital);
+  const fields = entity.fields.map((f) => ({
+    name: f.name ?? "",
+    type: f.type ?? "string",
+    required: f.required ?? false,
+    hasDefault: f.default !== void 0
+  }));
+  const traitInfos = traits.map((t) => {
+    const sm = getStateMachine(t);
+    return {
+      name: t.name ?? "",
+      stateCount: sm ? getStates(sm).length : 0,
+      eventCount: sm ? getEvents(sm).length : 0,
+      transitionCount: sm ? getTransitions(sm).length : 0,
+      emits: getEmits(t),
+      listens: getListens(t)
+    };
+  });
+  const pageInfos = pages.map((p) => ({
+    name: p.name ?? "",
+    route: p.path ?? `/${(p.name ?? "").toLowerCase()}`
+  }));
+  const externalLinks = [];
+  for (const w of traitEventWires(schema)) {
+    if (w.emitterOrbital === w.listenerOrbital) continue;
+    if (w.emitterOrbital === orbitalName) {
+      externalLinks.push({ targetOrbital: w.listenerOrbital, eventName: w.event, direction: "out", traitName: w.emitterTrait });
+    } else if (w.listenerOrbital === orbitalName) {
+      externalLinks.push({ targetOrbital: w.emitterOrbital, eventName: w.event, direction: "in", traitName: w.listenerTrait });
+    }
+  }
+  return {
+    name: orbital.name,
+    entity: {
+      name: entity.name,
+      fields,
+      persistence: entity.persistence
+    },
+    traits: traitInfos,
+    pages: pageInfos,
+    externalLinks
+  };
+}
+function traitTransitionRenderUi(schema, orbitalName, traitName) {
+  const orbital = schema.orbitals?.find((o) => o.name === orbitalName);
+  const trait = orbital ? getTraits(orbital).find((t) => t.name === traitName) : void 0;
+  const sm = trait ? getStateMachine(trait) : void 0;
+  return sm ? getTransitions(sm).map((t) => renderUiEntriesOf(jsonEffects(t))) : [];
+}
+function parseTraitLevel(schema, orbitalName, traitName) {
+  if (!schema.orbitals) return null;
+  const orbital = schema.orbitals.find((o) => o.name === orbitalName);
+  if (!orbital) return null;
+  const trait = getTraits(orbital).find((t) => t.name === traitName);
+  if (!trait) return null;
+  return traitLevelFromTrait(trait, getEntity(orbital).name);
+}
+function programTraits(schema) {
+  return (schema.orbitals ?? []).flatMap((orbital) => {
+    const entity = getEntity(orbital).name;
+    return getTraits(orbital).flatMap((trait) => {
+      const level = traitLevelFromTrait(trait, entity);
+      return level ? [{ orbital: orbital.name, trait, level }] : [];
+    });
+  });
+}
+function traitLevelFromTrait(trait, linkedEntity) {
+  const sm = getStateMachine(trait);
+  if (!sm) return null;
+  return traitLevelOf(trait.name, linkedEntity, sm, getEmits(trait), getListens(trait));
+}
+function traitLevelFromDescription(description) {
+  const machine = description.machine;
+  if (!machine) return null;
+  return traitLevelOf(
+    description.value.trait,
+    machine.linkedEntity ?? "",
+    machine.stateMachine,
+    description.events.emits,
+    description.events.listens
+  );
+}
+function traitLevelFromMounted(trait) {
+  return {
+    name: trait.trait,
+    linkedEntity: trait.linkedEntity ?? "",
+    states: trait.states.map((s) => ({ name: s.name, isInitial: s.isInitial, isTerminal: s.isTerminal })),
+    transitions: trait.transitions.flatMap(
+      (t) => t.from.map((from) => ({ from, to: t.to, event: t.event, guard: null, effects: [], index: t.index }))
+    ),
+    emittedEvents: trait.emits,
+    listenedEvents: trait.listens.map((l) => l.event)
+  };
+}
+function traitLevelOf(name, linkedEntity, sm, emittedEvents, listenedEvents) {
+  const states = getStates(sm).map((s) => ({
+    name: s.name ?? "",
+    isInitial: s.isInitial ?? null,
+    isTerminal: s.isTerminal ?? s.isFinal ?? null
+  }));
+  const transitions = getTransitions(sm).map((t, i) => ({
+    from: t.from ?? "",
+    to: t.to ?? "",
+    event: t.event ?? "",
+    guard: t.guard ?? null,
+    effects: jsonEffects(t).map(parseEffectType),
+    index: i
+  }));
+  return {
+    name,
+    linkedEntity,
+    states,
+    transitions,
+    emittedEvents,
+    listenedEvents
+  };
+}
+function parseTransitionLevel(schema, orbitalName, traitName, transitionIndex) {
+  const traitData = parseTraitLevel(schema, orbitalName, traitName);
+  if (!traitData) return null;
+  const transition = traitData.transitions[transitionIndex];
+  if (!transition) return null;
+  const guardVal = transition.guard;
+  const guard = guardVal != null ? exprToTree(guardVal) : null;
+  const effects = transition.effects.map(
+    (e) => exprToTree([e.type, ...e.args])
+  );
+  const slotTargets = transition.effects.filter((e) => e.type === "render-ui").map((e) => ({
+    name: String(e.args[0] ?? "main"),
+    pattern: typeof e.args[1] === "object" && e.args[1] !== null && !Array.isArray(e.args[1]) ? e.args[1].type ?? "unknown" : String(e.args[1] ?? "unknown")
+  }));
+  return {
+    from: transition.from,
+    to: transition.to,
+    event: transition.event,
+    guard,
+    effects,
+    slotTargets
+  };
+}
+
+export { parseApplicationLevel, parseOrbitalLevel, parseTraitLevel, parseTransitionLevel, programTraits, traitEventWires, traitLevelFromDescription, traitLevelFromMounted, traitLevelFromTrait, traitTransitionRenderUi };