@jucie.io/cli 1.0.0

package/dist/stage-bundles/preact/chunks/chunk-6RLI7CFQ.js

@@ -0,0 +1,12 @@
+// ../scene-graph/stores/factories/createValue.js
+function createValue({ key, type, value = "" }) {
+  return {
+    key,
+    type,
+    value
+  };
+}
+
+export {
+  createValue
+};

package/dist/stage-bundles/preact/chunks/chunk-6TDZGYJG.js

@@ -0,0 +1,13 @@
+// ../scene-graph/nodes/factories/createLifecycleHook.js
+function createLifecycleHook({ key, mode, binding = null, code = "" }) {
+  return {
+    key,
+    mode: mode ?? "binding",
+    binding,
+    code
+  };
+}
+
+export {
+  createLifecycleHook
+};

package/dist/stage-bundles/preact/chunks/chunk-AI3MQHWR.js

@@ -0,0 +1,51 @@
+// ../scene-graph/utils/expressions.js
+var keywords = /* @__PURE__ */ new Set([
+  "true",
+  "false",
+  "null",
+  "undefined",
+  "this",
+  "return",
+  "if",
+  "else",
+  "for",
+  "while",
+  "function",
+  "var",
+  "let",
+  "const",
+  "new",
+  "typeof",
+  "instanceof",
+  "Array",
+  "Object",
+  "String",
+  "Number",
+  "Boolean",
+  "Date",
+  "Math",
+  "JSON",
+  "console",
+  "window",
+  "document"
+]);
+function hasExpression(value) {
+  return typeof value === "string" && value.includes("{{");
+}
+function parseExpression(value) {
+  if (!hasExpression(value)) return null;
+  const match = value.match(/^\{\{(.+)\}\}$/);
+  return match ? match[1].trim() : null;
+}
+function parseDependencies(expression) {
+  if (!expression) return [];
+  const matches = expression.matchAll(/(?<![.\w])([a-zA-Z_$][\w]*)/g);
+  const deps = [...new Set([...matches].map((m) => m[1]))];
+  return deps.filter((dep) => !keywords.has(dep));
+}
+
+export {
+  hasExpression,
+  parseExpression,
+  parseDependencies
+};

package/dist/stage-bundles/preact/chunks/chunk-BWZPEI76.js

@@ -0,0 +1,18 @@
+import {
+  clearValueChannelConflict,
+  createAttribute
+} from "./chunk-TKHCH4WB.js";
+
+// ../scene-graph/nodes/mutations/addAttribute.js
+function addAttribute(state, id, input = {}) {
+  const opts = typeof input === "string" ? { name: input } : input;
+  const desc = createAttribute(opts);
+  if (desc.name) {
+    clearValueChannelConflict(state, id, desc.name);
+  }
+  return state.unshift([id, "attributes"], desc);
+}
+
+export {
+  addAttribute
+};

package/dist/stage-bundles/preact/chunks/chunk-CHZVDVQC.js

@@ -0,0 +1,8 @@
+// ../scene-graph/nodes/mutations/removeOption.js
+function removeOption(state, id, value) {
+  return state.removeWhere([id, "options", "set"], { value });
+}
+
+export {
+  removeOption
+};

package/dist/stage-bundles/preact/chunks/chunk-CJOJNMRC.js

@@ -0,0 +1,8 @@
+// ../scene-graph/nodes/mutations/setTagName.js
+function setTagName(state, id, tagName) {
+  return state.set([id, "tagName"], tagName);
+}
+
+export {
+  setTagName
+};

package/dist/stage-bundles/preact/chunks/chunk-CXATTVPL.js

@@ -0,0 +1,24 @@
+// ../scene-graph/nodes/mutations/clearOptionsExpression.js
+function clearOptionsExpression(state, id) {
+  return state.update([id, "options"], (options = {}) => ({
+    ...options,
+    type: "set",
+    binding: null,
+    expression: null,
+    dependencies: [],
+    valueKey: {
+      value: "value",
+      expression: null,
+      dependencies: []
+    },
+    labelKey: {
+      value: "label",
+      expression: null,
+      dependencies: []
+    }
+  }));
+}
+
+export {
+  clearOptionsExpression
+};

package/dist/stage-bundles/preact/chunks/chunk-CYH47R7O.js

@@ -0,0 +1,49 @@
+import {
+  createFrameOverrides
+} from "./chunk-6R3QXFFF.js";
+import {
+  createNode
+} from "./chunk-UFHA3ODE.js";
+import {
+  moveNodeToLastChildOf
+} from "./chunk-236DY7EE.js";
+
+// ../scene-graph/nodes/operations/createNodeEntry.js
+function buildFrameNodeProps(props = {}) {
+  const presetKey = props.frame ?? props.viewport;
+  if (!presetKey) return props;
+  const { frame, viewport, width, height, name, bounds: boundsOverride, ...rest } = props;
+  const { name: presetName, bounds } = createFrameOverrides(presetKey, { name, width, height });
+  return {
+    ...rest,
+    frame: presetKey,
+    name: presetName,
+    bounds: {
+      x: boundsOverride?.x ?? bounds.x ?? 0,
+      y: boundsOverride?.y ?? bounds.y ?? 0,
+      width: boundsOverride?.width ?? bounds.width,
+      height: boundsOverride?.height ?? bounds.height
+    }
+  };
+}
+function createNodeEntry(state, type, props = {}) {
+  const nodeProps = type === "frame" ? buildFrameNodeProps(props) : props;
+  const [id, node] = createNode(type, nodeProps);
+  if (type === "frame") {
+    node.route = { path: `${id}` };
+  }
+  state.set([id], node);
+  return id;
+}
+
+// ../scene-graph/nodes/operations/addNode.js
+function addNode(state, type, props, parent = "app") {
+  const id = createNodeEntry(state, type, props);
+  moveNodeToLastChildOf(state, id, parent);
+  return id;
+}
+
+export {
+  createNodeEntry,
+  addNode
+};

package/dist/stage-bundles/preact/chunks/chunk-DBHMBCBM.js

@@ -0,0 +1,14 @@
+// ../scene-graph/stores/mutations/removeComputed.js
+function removeComputed(state, id, index) {
+  return state.update([id, "computed"], (computedItems = []) => {
+    if (!computedItems[index]) {
+      return computedItems;
+    }
+    computedItems.splice(index, 1);
+    return computedItems;
+  });
+}
+
+export {
+  removeComputed
+};

package/dist/stage-bundles/preact/chunks/chunk-DCKGUW2M.js

@@ -0,0 +1,8 @@
+// ../scene-graph/nodes/mutations/updateHtml.js
+function updateHtml(state, id, html) {
+  return state.set([id, "html"], html);
+}
+
+export {
+  updateHtml
+};

package/dist/stage-bundles/preact/chunks/chunk-EB5FGFFG.js

@@ -0,0 +1,12 @@
+import {
+  createLifecycleHook
+} from "./chunk-6TDZGYJG.js";
+
+// ../scene-graph/nodes/mutations/updateLifecycleHook.js
+function updateLifecycleHook(state, id, key, hook) {
+  return state.setWhere([id, "lifecycle"], { key }, createLifecycleHook(hook));
+}
+
+export {
+  updateLifecycleHook
+};

package/dist/stage-bundles/preact/chunks/chunk-F6JYAVEC.js

@@ -0,0 +1,15 @@
+import {
+  createCode
+} from "./chunk-RI7XWDHX.js";
+
+// ../scene-graph/stores/factories/createComputed.js
+function createComputed({ name, code = createCode() }) {
+  return {
+    name,
+    code
+  };
+}
+
+export {
+  createComputed
+};

package/dist/stage-bundles/preact/chunks/chunk-F77HGOQB.js

@@ -0,0 +1,8 @@
+// ../scene-graph/nodes/mutations/clearDestination.js
+function clearDestination(state, id) {
+  return state.remove([id, "destination"]);
+}
+
+export {
+  clearDestination
+};

package/dist/stage-bundles/preact/chunks/chunk-FSIANI7E.js

@@ -0,0 +1,11 @@
+// ../scene-graph/nodes/factories/createOption.js
+function createOption({ value, label }) {
+  return {
+    value,
+    label: label || value
+  };
+}
+
+export {
+  createOption
+};

package/dist/stage-bundles/preact/chunks/chunk-FZZDMYBZ.js

@@ -0,0 +1,12 @@
+// ../scene-graph/tokens/mutations/updateToken.js
+function updateToken(state, id, changes) {
+  const current = state.get([id]);
+  if (!current) return;
+  for (const [key, value] of Object.entries(changes)) {
+    state.set([id, key], value);
+  }
+}
+
+export {
+  updateToken
+};

package/dist/stage-bundles/preact/chunks/chunk-H75SQT4U.js

@@ -0,0 +1,105 @@
+import {
+  parseDependencies
+} from "./chunk-AI3MQHWR.js";
+import {
+  createDescriptorId
+} from "./chunk-S5L2YBXG.js";
+
+// ../scene-graph/nodes/factories/createDescriptor.js
+var VALID_MODES = /* @__PURE__ */ new Set(["value", "binding", "computed", "code"]);
+var DEFAULT_COMPUTED = "function (ctx) {\n  return true\n}";
+var DEFAULT_CODE = "function (ctx, event) {\n  \n}";
+var DEFAULTS = () => ({
+  name: null,
+  mode: "value",
+  value: null,
+  binding: null,
+  computed: null,
+  code: null,
+  error: null,
+  removable: true
+});
+function validateCode(code) {
+  if (code == null || code === "") return null;
+  try {
+    new Function("ctx", "event", code);
+    return null;
+  } catch (_) {
+    try {
+      new Function(`return (${code})`);
+      return null;
+    } catch (e) {
+      return e.message;
+    }
+  }
+}
+function validateComputed(computed) {
+  if (computed == null || computed === "") return null;
+  try {
+    new Function("ctx", computed);
+    return null;
+  } catch (_) {
+    try {
+      new Function("ctx", `return (${computed})`);
+      return null;
+    } catch (e) {
+      return e.message;
+    }
+  }
+}
+function validateBinding(binding) {
+  if (binding == null) return null;
+  if (!Array.isArray(binding) || binding.length === 0) {
+    return "binding must be a non-empty array of strings";
+  }
+  if (!binding.every((s) => typeof s === "string" && s.length > 0)) {
+    return "every segment in binding must be a non-empty string";
+  }
+  return null;
+}
+function validateDescriptor(descriptor) {
+  const out = { ...descriptor, error: null };
+  switch (out.mode) {
+    case "code":
+      out.error = validateCode(out.code);
+      break;
+    case "computed":
+      out.error = validateComputed(out.computed);
+      break;
+    case "binding":
+      out.error = validateBinding(out.binding);
+      break;
+    case "value":
+    default:
+      break;
+  }
+  return out;
+}
+function createDescriptor(input = {}) {
+  const desc = DEFAULTS();
+  if (!input.id) input.id = createDescriptorId();
+  if (input.name != null) desc.name = input.name;
+  if (input.value !== void 0) desc.value = input.value;
+  if (input.binding != null) desc.binding = input.binding;
+  if (input.computed != null) desc.computed = input.computed;
+  if (input.code != null) desc.code = input.code;
+  if (input.mode && VALID_MODES.has(input.mode)) {
+    desc.mode = input.mode;
+  }
+  if (desc.mode === "computed" && !desc.computed) {
+    desc.computed = DEFAULT_COMPUTED;
+  }
+  if (desc.mode === "code" && !desc.code) {
+    desc.code = DEFAULT_CODE;
+  }
+  if (desc.mode === "computed" && desc.computed) {
+    desc.dependencies = parseDependencies(desc.computed);
+  }
+  if (input.removable === false) desc.removable = false;
+  return validateDescriptor(desc);
+}
+
+export {
+  DEFAULT_CODE,
+  createDescriptor
+};

package/dist/stage-bundles/preact/chunks/chunk-HPCVUQI4.js

@@ -0,0 +1,224 @@
+import {
+  l
+} from "./chunk-YXNMNEJV.js";
+import {
+  __export
+} from "./chunk-4A4WKSGY.js";
+
+// ../../node_modules/preact/hooks/dist/hooks.module.js
+var hooks_module_exports = {};
+__export(hooks_module_exports, {
+  useCallback: () => q,
+  useContext: () => x,
+  useDebugValue: () => P,
+  useEffect: () => h,
+  useErrorBoundary: () => b,
+  useId: () => g,
+  useImperativeHandle: () => F,
+  useLayoutEffect: () => _,
+  useMemo: () => T,
+  useReducer: () => y,
+  useRef: () => A,
+  useState: () => d
+});
+var t;
+var r;
+var u;
+var i;
+var o = 0;
+var f = [];
+var c = l;
+var e = c.__b;
+var a = c.__r;
+var v = c.diffed;
+var l2 = c.__c;
+var m = c.unmount;
+var p = c.__;
+function s(n, t2) {
+  c.__h && c.__h(r, n, o || t2), o = 0;
+  var u2 = r.__H || (r.__H = { __: [], __h: [] });
+  return n >= u2.__.length && u2.__.push({}), u2.__[n];
+}
+function d(n) {
+  return o = 1, y(D, n);
+}
+function y(n, u2, i2) {
+  var o2 = s(t++, 2);
+  if (o2.t = n, !o2.__c && (o2.__ = [i2 ? i2(u2) : D(void 0, u2), function(n2) {
+    var t2 = o2.__N ? o2.__N[0] : o2.__[0], r2 = o2.t(t2, n2);
+    t2 !== r2 && (o2.__N = [r2, o2.__[1]], o2.__c.setState({}));
+  }], o2.__c = r, !r.__f)) {
+    var f2 = function(n2, t2, r2) {
+      if (!o2.__c.__H) return true;
+      var u3 = false, i3 = o2.__c.props !== n2;
+      if (o2.__c.__H.__.some(function(n3) {
+        if (n3.__N) {
+          u3 = true;
+          var t3 = n3.__[0];
+          n3.__ = n3.__N, n3.__N = void 0, t3 !== n3.__[0] && (i3 = true);
+        }
+      }), c2) {
+        var f3 = c2.call(this, n2, t2, r2);
+        return u3 ? f3 || i3 : f3;
+      }
+      return !u3 || i3;
+    };
+    r.__f = true;
+    var c2 = r.shouldComponentUpdate, e2 = r.componentWillUpdate;
+    r.componentWillUpdate = function(n2, t2, r2) {
+      if (this.__e) {
+        var u3 = c2;
+        c2 = void 0, f2(n2, t2, r2), c2 = u3;
+      }
+      e2 && e2.call(this, n2, t2, r2);
+    }, r.shouldComponentUpdate = f2;
+  }
+  return o2.__N || o2.__;
+}
+function h(n, u2) {
+  var i2 = s(t++, 3);
+  !c.__s && C(i2.__H, u2) && (i2.__ = n, i2.u = u2, r.__H.__h.push(i2));
+}
+function _(n, u2) {
+  var i2 = s(t++, 4);
+  !c.__s && C(i2.__H, u2) && (i2.__ = n, i2.u = u2, r.__h.push(i2));
+}
+function A(n) {
+  return o = 5, T(function() {
+    return { current: n };
+  }, []);
+}
+function F(n, t2, r2) {
+  o = 6, _(function() {
+    if ("function" == typeof n) {
+      var r3 = n(t2());
+      return function() {
+        n(null), r3 && "function" == typeof r3 && r3();
+      };
+    }
+    if (n) return n.current = t2(), function() {
+      return n.current = null;
+    };
+  }, null == r2 ? r2 : r2.concat(n));
+}
+function T(n, r2) {
+  var u2 = s(t++, 7);
+  return C(u2.__H, r2) && (u2.__ = n(), u2.__H = r2, u2.__h = n), u2.__;
+}
+function q(n, t2) {
+  return o = 8, T(function() {
+    return n;
+  }, t2);
+}
+function x(n) {
+  var u2 = r.context[n.__c], i2 = s(t++, 9);
+  return i2.c = n, u2 ? (null == i2.__ && (i2.__ = true, u2.sub(r)), u2.props.value) : n.__;
+}
+function P(n, t2) {
+  c.useDebugValue && c.useDebugValue(t2 ? t2(n) : n);
+}
+function b(n) {
+  var u2 = s(t++, 10), i2 = d();
+  return u2.__ = n, r.componentDidCatch || (r.componentDidCatch = function(n2, t2) {
+    u2.__ && u2.__(n2, t2), i2[1](n2);
+  }), [i2[0], function() {
+    i2[1](void 0);
+  }];
+}
+function g() {
+  var n = s(t++, 11);
+  if (!n.__) {
+    for (var u2 = r.__v; null !== u2 && !u2.__m && null !== u2.__; ) u2 = u2.__;
+    var i2 = u2.__m || (u2.__m = [0, 0]);
+    n.__ = "P" + i2[0] + "-" + i2[1]++;
+  }
+  return n.__;
+}
+function j() {
+  for (var n; n = f.shift(); ) {
+    var t2 = n.__H;
+    if (n.__P && t2) try {
+      t2.__h.some(z), t2.__h.some(B), t2.__h = [];
+    } catch (r2) {
+      t2.__h = [], c.__e(r2, n.__v);
+    }
+  }
+}
+c.__b = function(n) {
+  r = null, e && e(n);
+}, c.__ = function(n, t2) {
+  n && t2.__k && t2.__k.__m && (n.__m = t2.__k.__m), p && p(n, t2);
+}, c.__r = function(n) {
+  a && a(n), t = 0;
+  var i2 = (r = n.__c).__H;
+  i2 && (u === r ? (i2.__h = [], r.__h = [], i2.__.some(function(n2) {
+    n2.__N && (n2.__ = n2.__N), n2.u = n2.__N = void 0;
+  })) : (i2.__h.some(z), i2.__h.some(B), i2.__h = [], t = 0)), u = r;
+}, c.diffed = function(n) {
+  v && v(n);
+  var t2 = n.__c;
+  t2 && t2.__H && (t2.__H.__h.length && (1 !== f.push(t2) && i === c.requestAnimationFrame || ((i = c.requestAnimationFrame) || w)(j)), t2.__H.__.some(function(n2) {
+    n2.u && (n2.__H = n2.u, n2.u = void 0);
+  })), u = r = null;
+}, c.__c = function(n, t2) {
+  t2.some(function(n2) {
+    try {
+      n2.__h.some(z), n2.__h = n2.__h.filter(function(n3) {
+        return !n3.__ || B(n3);
+      });
+    } catch (r2) {
+      t2.some(function(n3) {
+        n3.__h && (n3.__h = []);
+      }), t2 = [], c.__e(r2, n2.__v);
+    }
+  }), l2 && l2(n, t2);
+}, c.unmount = function(n) {
+  m && m(n);
+  var t2, r2 = n.__c;
+  r2 && r2.__H && (r2.__H.__.some(function(n2) {
+    try {
+      z(n2);
+    } catch (n3) {
+      t2 = n3;
+    }
+  }), r2.__H = void 0, t2 && c.__e(t2, r2.__v));
+};
+var k = "function" == typeof requestAnimationFrame;
+function w(n) {
+  var t2, r2 = function() {
+    clearTimeout(u2), k && cancelAnimationFrame(t2), setTimeout(n);
+  }, u2 = setTimeout(r2, 35);
+  k && (t2 = requestAnimationFrame(r2));
+}
+function z(n) {
+  var t2 = r, u2 = n.__c;
+  "function" == typeof u2 && (n.__c = void 0, u2()), r = t2;
+}
+function B(n) {
+  var t2 = r;
+  n.__c = n.__(), r = t2;
+}
+function C(n, t2) {
+  return !n || n.length !== t2.length || t2.some(function(t3, r2) {
+    return t3 !== n[r2];
+  });
+}
+function D(n, t2) {
+  return "function" == typeof t2 ? t2(n) : t2;
+}
+
+export {
+  d,
+  y,
+  h,
+  _,
+  A,
+  F,
+  T,
+  q,
+  x,
+  P,
+  b,
+  g,
+  hooks_module_exports
+};