@almadar/shell-web 0.0.0-stage → 0.1.0

package/dist/chunk-U6QRZASX.js

@@ -0,0 +1,280 @@
+import { cn, Typography, useTranslate, VStack, HStack, Icon, Button, Switch, Input } from './chunk-MBQAMMSE.js';
+import React from 'react';
+import { jsx, jsxs } from 'react/jsx-runtime';
+
+var isObj = (v) => v !== null && typeof v === "object" && !Array.isArray(v);
+var isArr = (v) => Array.isArray(v);
+function kindOf(v) {
+  if (v === null) return "null";
+  if (isArr(v)) return "array";
+  if (isObj(v)) return "object";
+  if (typeof v === "number") return "number";
+  if (typeof v === "boolean") return "boolean";
+  return "string";
+}
+var TYPE_LABEL_KEY = {
+  string: "jsonTree.type.text",
+  number: "jsonTree.type.number",
+  boolean: "jsonTree.type.boolean"
+};
+var TYPE_LABEL_SYMBOL = {
+  object: "{}",
+  array: "[]",
+  null: "\u2014"
+};
+function typeLabel(kind, t) {
+  if (kind === "object" || kind === "array" || kind === "null") return TYPE_LABEL_SYMBOL[kind];
+  return t(TYPE_LABEL_KEY[kind] ?? "");
+}
+var KIND_OPTIONS = ["string", "number", "boolean", "object", "array"];
+function emptyOf(kind) {
+  switch (kind) {
+    case "object":
+      return {};
+    case "array":
+      return [];
+    case "number":
+      return 0;
+    case "boolean":
+      return false;
+    case "null":
+      return null;
+    default:
+      return "";
+  }
+}
+function templateFrom(arr) {
+  if (arr.length === 0) return "";
+  const first = arr[0];
+  if (isObj(first)) {
+    const blank = {};
+    for (const k of Object.keys(first)) blank[k] = isObj(first[k]) ? {} : isArr(first[k]) ? [] : first[k];
+    return blank;
+  }
+  if (isArr(first)) return [];
+  return emptyOf(kindOf(first));
+}
+function ScalarControl({
+  value,
+  onChange
+}) {
+  if (typeof value === "boolean") {
+    return /* @__PURE__ */ jsx(Switch, { checked: value, onChange: (c) => onChange(c) });
+  }
+  const numeric = typeof value === "number";
+  const initial = value === null ? "" : String(value);
+  const [draft, setDraft] = React.useState(initial);
+  React.useEffect(() => setDraft(initial), [initial]);
+  const commit = () => {
+    if (numeric) {
+      const n = draft.trim() === "" ? 0 : Number(draft);
+      onChange(Number.isNaN(n) ? 0 : n);
+    } else {
+      onChange(draft);
+    }
+  };
+  return /* @__PURE__ */ jsx(
+    Input,
+    {
+      inputType: numeric ? "number" : "text",
+      value: draft,
+      placeholder: value === null ? "null" : void 0,
+      onChange: (e) => setDraft(e.target.value),
+      onBlur: commit,
+      onKeyDown: (e) => {
+        if (e.key === "Enter") commit();
+      }
+    }
+  );
+}
+function KindSelect({
+  kind,
+  onChange
+}) {
+  const { t } = useTranslate();
+  return /* @__PURE__ */ jsx(
+    "select",
+    {
+      value: kind === "null" ? "string" : kind,
+      onChange: (e) => onChange(e.target.value),
+      "aria-label": t("jsonTree.valueType"),
+      className: cn(
+        "h-6 rounded-interactive bg-muted text-muted-foreground text-[10px] font-mono px-1",
+        "border-[length:var(--border-width-thin)] border-border",
+        "hover:bg-card focus:outline-none focus:ring-1 focus:ring-ring"
+      ),
+      children: KIND_OPTIONS.map((k) => /* @__PURE__ */ jsx("option", { value: k, children: typeLabel(k, t) }, k))
+    }
+  );
+}
+function ValueNode({
+  value,
+  onChange,
+  depth,
+  readonly
+}) {
+  const kind = kindOf(value);
+  if (kind === "object" || kind === "array") {
+    return /* @__PURE__ */ jsx(ContainerNode, { value, onChange, depth, readonly });
+  }
+  if (readonly) {
+    return /* @__PURE__ */ jsx(Typography, { variant: "caption", className: "font-mono text-foreground", children: value === null ? "null" : String(value) });
+  }
+  return /* @__PURE__ */ jsx(ScalarControl, { value, onChange });
+}
+function Row({
+  rowKey,
+  isArrayItem,
+  value,
+  depth,
+  onValue,
+  onRenameKey,
+  onChangeKind,
+  onRemove,
+  readonly
+}) {
+  const { t } = useTranslate();
+  const [keyDraft, setKeyDraft] = React.useState(rowKey);
+  React.useEffect(() => setKeyDraft(rowKey), [rowKey]);
+  const container = isObj(value) || isArr(value);
+  return /* @__PURE__ */ jsxs(VStack, { gap: "none", className: "group w-max min-w-full", children: [
+    /* @__PURE__ */ jsxs(HStack, { gap: "xs", align: "center", className: "py-0.5 w-max", children: [
+      readonly ? /* @__PURE__ */ jsx("span", { className: cn(
+        "h-6 rounded-interactive bg-muted text-muted-foreground text-[10px] font-mono px-1 flex items-center",
+        "border-[length:var(--border-width-thin)] border-border"
+      ), children: typeLabel(kindOf(value), t) }) : /* @__PURE__ */ jsx(KindSelect, { kind: kindOf(value), onChange: onChangeKind }),
+      isArrayItem ? /* @__PURE__ */ jsx(Typography, { variant: "caption", color: "muted", className: "w-6 shrink-0 font-mono", children: rowKey }) : readonly ? /* @__PURE__ */ jsx(Typography, { variant: "caption", color: "muted", className: "w-20 shrink-0 font-mono truncate", children: rowKey }) : /* @__PURE__ */ jsx("div", { className: "w-20 shrink-0", children: /* @__PURE__ */ jsx(
+        Input,
+        {
+          inputType: "text",
+          value: keyDraft,
+          onChange: (e) => setKeyDraft(e.target.value),
+          onBlur: () => keyDraft !== rowKey && onRenameKey(keyDraft),
+          onKeyDown: (e) => {
+            if (e.key === "Enter" && keyDraft !== rowKey) onRenameKey(keyDraft);
+          },
+          className: "font-mono"
+        }
+      ) }),
+      !container && /* @__PURE__ */ jsx("div", { className: "w-48 shrink-0", children: /* @__PURE__ */ jsx(ValueNode, { value, onChange: onValue, depth: depth + 1, readonly }) }),
+      !readonly && /* @__PURE__ */ jsx(
+        Button,
+        {
+          variant: "ghost",
+          size: "sm",
+          icon: "x",
+          onClick: onRemove,
+          "aria-label": t("common.remove"),
+          className: "shrink-0 text-muted-foreground hover:text-error"
+        }
+      )
+    ] }),
+    container && /* @__PURE__ */ jsx("div", { className: "pl-2", children: /* @__PURE__ */ jsx(ValueNode, { value, onChange: onValue, depth: depth + 1, readonly }) })
+  ] });
+}
+function ContainerNode({
+  value,
+  onChange,
+  depth,
+  readonly
+}) {
+  const { t } = useTranslate();
+  const [open, setOpen] = React.useState(depth < 2);
+  const array = isArr(value);
+  const entries = array ? value.map((v, i) => [String(i), v]) : Object.entries(value);
+  const setObjValue = (key, next) => {
+    onChange({ ...value, [key]: next });
+  };
+  const renameKey = (oldKey, newKey) => {
+    if (!newKey || newKey === oldKey) return;
+    const out = {};
+    for (const [k, v] of Object.entries(value)) out[k === oldKey ? newKey : k] = v;
+    onChange(out);
+  };
+  const removeObjKey = (key) => {
+    const out = {};
+    for (const [k, v] of Object.entries(value)) if (k !== key) out[k] = v;
+    onChange(out);
+  };
+  const changeObjKind = (key, k) => setObjValue(key, emptyOf(k));
+  const setArrValue = (idx, next) => {
+    const copy = [...value];
+    copy[idx] = next;
+    onChange(copy);
+  };
+  const removeArrIdx = (idx) => onChange(value.filter((_, i) => i !== idx));
+  const changeArrKind = (idx, k) => setArrValue(idx, emptyOf(k));
+  const add = () => {
+    if (array) {
+      onChange([...value, templateFrom(value)]);
+    } else {
+      const obj = value;
+      let key = "key";
+      let n = 1;
+      while (key in obj) {
+        key = `key${n}`;
+        n += 1;
+      }
+      onChange({ ...obj, [key]: "" });
+    }
+  };
+  const summaryKey = array ? entries.length === 1 ? "jsonTree.itemCountOne" : "jsonTree.itemCountOther" : entries.length === 1 ? "jsonTree.fieldCountOne" : "jsonTree.fieldCountOther";
+  const summary = t(summaryKey, { count: entries.length });
+  return /* @__PURE__ */ jsxs(VStack, { gap: "none", className: "w-full", children: [
+    /* @__PURE__ */ jsx(HStack, { gap: "xs", align: "center", children: /* @__PURE__ */ jsxs(
+      "button",
+      {
+        type: "button",
+        onClick: () => setOpen((o) => !o),
+        className: "flex items-center gap-1 text-muted-foreground hover:text-foreground",
+        "aria-label": open ? t("jsonTree.collapse") : t("jsonTree.expand"),
+        children: [
+          /* @__PURE__ */ jsx(Icon, { name: open ? "chevron-down" : "chevron-right", size: "sm" }),
+          /* @__PURE__ */ jsx("span", { className: "font-mono text-xs", children: array ? "[ ]" : "{ }" }),
+          /* @__PURE__ */ jsx(Typography, { variant: "caption", color: "muted", children: summary })
+        ]
+      }
+    ) }),
+    open && /* @__PURE__ */ jsxs(
+      VStack,
+      {
+        gap: "none",
+        className: cn("ml-1.5 pl-1.5 w-max min-w-full border-l-[length:var(--border-width-thin)] border-border"),
+        children: [
+          entries.map(([k, v], idx) => /* @__PURE__ */ jsx(
+            Row,
+            {
+              rowKey: k,
+              isArrayItem: array,
+              value: v,
+              depth,
+              onValue: (next) => array ? setArrValue(idx, next) : setObjValue(k, next),
+              onRenameKey: (nk) => renameKey(k, nk),
+              onChangeKind: (kind) => array ? changeArrKind(idx, kind) : changeObjKind(k, kind),
+              onRemove: () => array ? removeArrIdx(idx) : removeObjKey(k),
+              readonly
+            },
+            array ? idx : k
+          )),
+          !readonly && /* @__PURE__ */ jsx(
+            Button,
+            {
+              variant: "ghost",
+              size: "sm",
+              icon: "plus",
+              label: array ? t("jsonTree.addItem") : t("jsonTree.addField"),
+              onClick: add,
+              className: "self-start text-muted-foreground"
+            }
+          )
+        ]
+      }
+    )
+  ] });
+}
+var JsonTreeEditor = ({ value, onChange, className, readonly }) => {
+  const root = value ?? "";
+  return /* @__PURE__ */ jsx("div", { className: cn("w-full overflow-x-auto rounded-container bg-card/40 p-2 border-[length:var(--border-width-thin)] border-border", className), children: /* @__PURE__ */ jsx(ValueNode, { value: root, onChange, depth: 0, readonly }) });
+};
+
+export { JsonTreeEditor };

package/dist/chunk-VFF5OO47.js

@@ -0,0 +1,319 @@
+import { routing_exports } from './chunk-DYEKAA4L.js';
+import { renderUiEntriesOf } from '@almadar/core/patterns';
+import { isInlineTrait } from '@almadar/core';
+
+function instanceOf(orbital, orbitalId, ref) {
+  const at = orbitalId === void 0 ? { orbital } : { orbital, orbitalId };
+  if (isInlineTrait(ref)) return { ...at, name: ref.name, trait: ref };
+  if (typeof ref === "object" && ref._resolved) return { ...at, name: ref.name ?? ref._resolved.name, trait: ref._resolved };
+  return null;
+}
+var wiresBySchema = /* @__PURE__ */ new WeakMap();
+function traitEventWires(schema) {
+  const cached = wiresBySchema.get(schema);
+  if (cached) return cached;
+  const instances = (schema.orbitals ?? []).flatMap(
+    (o) => (o.traits ?? []).map((ref) => instanceOf(o.name, o.id, ref)).filter((i) => i !== null)
+  );
+  const listensByEvent = /* @__PURE__ */ new Map();
+  for (const listener of instances) {
+    for (const listen of listener.trait.listens ?? []) {
+      const { bareEvent, matcher } = (0, routing_exports.parseListenSource)(listen, listener.orbital);
+      const bucket = listensByEvent.get(bareEvent);
+      if (bucket) bucket.push({ listener, matcher });
+      else listensByEvent.set(bareEvent, [{ listener, matcher }]);
+    }
+  }
+  const wires = [];
+  for (const emitter of instances) {
+    const source = { orbital: emitter.orbital, trait: emitter.name, ...emitter.orbitalId ? { orbitalId: emitter.orbitalId } : {}, ...emitter.trait.id ? { traitId: emitter.trait.id } : {} };
+    for (const emit of emitter.trait.emits ?? []) {
+      for (const { listener, matcher } of listensByEvent.get(emit.event) ?? []) {
+        if (listener.orbital === emitter.orbital && listener.name === emitter.name) continue;
+        if (!matcher(source)) continue;
+        wires.push({
+          emitterOrbital: emitter.orbital,
+          emitterTrait: emitter.name,
+          listenerOrbital: listener.orbital,
+          listenerTrait: listener.name,
+          event: emit.event
+        });
+      }
+    }
+  }
+  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 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, traitLevelFromTrait, traitTransitionRenderUi };