@jucie.io/cli 1.0.0

package/dist/stage-bundles/react/chunks/chunk-ABVPSM2D.js

@@ -0,0 +1,278 @@
+import {
+  require_client
+} from "./chunk-ZP3VSN3A.js";
+import {
+  require_react
+} from "./chunk-QVH24VHP.js";
+import {
+  __export,
+  __toESM
+} from "./chunk-ZHZLVPR6.js";
+
+// ../jucie-sdk/src/react/index.js
+var react_exports = {};
+__export(react_exports, {
+  Jucie: () => Jucie,
+  JucieInstance: () => JucieInstance,
+  JucieRoot: () => JucieRoot,
+  createElement: () => import_react2.createElement,
+  createHost: () => createHost,
+  createRef: () => createRef,
+  createRoot: () => import_client2.createRoot,
+  createTrigger: () => createTrigger,
+  defineJucieComponent: () => defineJucieComponent,
+  hostRootProps: () => hostRootProps,
+  loadProjectMain: () => loadProjectMain,
+  mergeInjected: () => mergeInjected,
+  provideJucie: () => provideJucie,
+  renderSource: () => renderSource,
+  setup: () => setup,
+  splitInstanceOverrides: () => splitInstanceOverrides,
+  useJucie: () => useJucie
+});
+var import_react = __toESM(require_react(), 1);
+var import_client = __toESM(require_client(), 1);
+
+// ../jucie-sdk/src/lib/splitInstanceOverrides.js
+var DOM_KEYS = /* @__PURE__ */ new Set(["className", "style", "id", "ref", "key"]);
+function splitInstanceOverrides(overrides) {
+  const dom = {};
+  const props = {};
+  if (!overrides) return { dom, props };
+  for (const key in overrides) {
+    if (DOM_KEYS.has(key) || key.startsWith("data-") || /^on[A-Z]/.test(key)) {
+      dom[key] = overrides[key];
+    } else {
+      props[key] = overrides[key];
+    }
+  }
+  return { dom, props };
+}
+
+// ../jucie-sdk/src/lib/setup.js
+var fns = [];
+function setup(fn) {
+  return fn;
+}
+function registerSetup(fn) {
+  if (typeof fn === "function") fns.push(fn);
+}
+async function loadProjectMain() {
+  const mod = await import("/user-main.js");
+  if (mod && "__jucieMainStub" in mod && mod.__jucieMainStub) return;
+  if (typeof mod?.default !== "function") {
+    throw new Error(
+      "[jucie] src/main.js must default-export setup(...), e.g. export default setup((app) => { ... })"
+    );
+  }
+  registerSetup(mod.default);
+}
+function applySetupWrappers(tree) {
+  return fns.reduceRight((t, fn) => {
+    const next = fn(t);
+    return next === void 0 ? t : next;
+  }, tree);
+}
+
+// ../jucie-sdk/src/lib/useJucie.js
+var JUCIE_KEY = Symbol("@jucie/runtime");
+var provideJucie = (jucie) => {
+  globalThis[JUCIE_KEY] = jucie;
+};
+var useJucie = () => {
+  return globalThis[JUCIE_KEY];
+};
+
+// ../jucie-sdk/src/react/index.js
+var import_react2 = __toESM(require_react(), 1);
+var import_client2 = __toESM(require_client(), 1);
+function hostRootProps(rootId) {
+  return { ref: rootId };
+}
+function createRef() {
+  return { current: null };
+}
+function createTrigger() {
+  let version = 0;
+  let listeners = [];
+  let pending = false;
+  const subscribe = (callback) => {
+    listeners.push(callback);
+    return () => {
+      listeners = listeners.filter((l) => l !== callback);
+    };
+  };
+  const getSnapshot = () => version;
+  const invalidate = () => {
+    if (pending) return;
+    pending = true;
+    Promise.resolve().then(() => {
+      pending = false;
+      version++;
+      listeners.forEach((l) => l());
+    });
+  };
+  const subscribeToTrigger = () => (0, import_react.useSyncExternalStore)(
+    subscribe,
+    getSnapshot,
+    getSnapshot
+  );
+  return [subscribeToTrigger, invalidate];
+}
+function createHost(el, renderRoot) {
+  const root = (0, import_client.createRoot)(el);
+  let rootId = null;
+  const jucie = () => renderRoot(rootId);
+  const paint = () => root.render(applySetupWrappers((0, import_react.createElement)(jucie)));
+  return {
+    jucie,
+    mount(id) {
+      rootId = id;
+      paint();
+      return this;
+    },
+    navigate(id) {
+      rootId = id;
+      paint();
+    },
+    unmount() {
+      root.unmount();
+    }
+  };
+}
+var JucieInstance = (0, import_react.createContext)(null);
+function composeRefs(...refs) {
+  return (node) => {
+    for (const ref of refs) {
+      if (!ref) continue;
+      if (typeof ref === "function") ref(node);
+      else ref.current = node;
+    }
+  };
+}
+function mergeInjected(base, inj) {
+  const out = { ...base || {} };
+  if (!inj) return out;
+  for (const key in inj) {
+    const a = out[key];
+    const b = inj[key];
+    if (key === "className") {
+      out.className = [a, b].filter(Boolean).join(" ");
+    } else if (key === "style") {
+      out.style = a || b ? { ...b, ...a } : void 0;
+    } else if (/^on[A-Z]/.test(key) && typeof a === "function" && typeof b === "function") {
+      out[key] = (...args) => {
+        a(...args);
+        b(...args);
+      };
+    } else if (key === "ref") {
+      out.ref = a ? composeRefs(b, a) : b;
+    } else {
+      out[key] = b;
+    }
+  }
+  return out;
+}
+var JucieRoot = (0, import_react.forwardRef)(function JucieRoot2({ as = "div", children, ...authorProps }, authorRef) {
+  const inj = (0, import_react.useContext)(JucieInstance);
+  const base = authorRef ? { ...authorProps, ref: authorRef } : authorProps;
+  if (!inj) return (0, import_react.createElement)(as, base, children);
+  return (0, import_react.createElement)(as, mergeInjected(base, inj), children);
+});
+JucieRoot.$jucieRoot = true;
+var tagCache = /* @__PURE__ */ new Map();
+var Jucie = new Proxy(
+  {},
+  {
+    get(_t, tag) {
+      if (typeof tag !== "string") return void 0;
+      if (!tagCache.has(tag)) {
+        const Tagged = (0, import_react.forwardRef)(
+          (props, ref) => (0, import_react.createElement)(JucieRoot, { as: tag, ...props, ref })
+        );
+        Tagged.displayName = `Jucie.${tag}`;
+        Tagged.$jucieRoot = true;
+        tagCache.set(tag, Tagged);
+      }
+      return tagCache.get(tag);
+    }
+  }
+);
+function defineJucieComponent(Component) {
+  Component.$jucie = true;
+  return Component;
+}
+var DEV = typeof process !== "undefined" && false;
+var warned = /* @__PURE__ */ new WeakSet();
+function warnOnce(Component, message) {
+  if (!DEV || !Component || warned.has(Component)) return;
+  warned.add(Component);
+  console.warn(message);
+}
+function componentLabel(Component) {
+  return Component.displayName || Component.name || "Component";
+}
+function SourceInstance({ Component, props, dom }) {
+  if (Component.$jucie) return (0, import_react.createElement)(Component, props);
+  if (typeof Component !== "function" || Component.prototype?.isReactComponent) {
+    warnOnce(
+      Component,
+      `[jucie] <${componentLabel(Component)}> is not a plain function component; wrap its root in <Jucie.div> so styling/selection can attach.`
+    );
+    return (0, import_react.createElement)(Component, mergeInjected(props, dom));
+  }
+  let rendered;
+  try {
+    rendered = Component(props);
+  } catch (error) {
+    console.error("[jucie] error rendering source component", error);
+    return (0, import_react.createElement)(Component, props);
+  }
+  if (!(0, import_react.isValidElement)(rendered) || rendered.type === import_react.Fragment) {
+    if (rendered != null) {
+      warnOnce(
+        Component,
+        `[jucie] <${componentLabel(Component)}> did not render a single root element; styling/selection cannot attach. Use <Jucie.div> as the root.`
+      );
+    }
+    return rendered ?? null;
+  }
+  if (rendered.type?.$jucieRoot || rendered.props?.["data-rid"] === dom["data-rid"]) {
+    return rendered;
+  }
+  warnOnce(
+    Component,
+    `[jucie] <${componentLabel(Component)}> does not forward props to its root; falling back to cloneElement. Prefer <Jucie.div> as the root.`
+  );
+  return (0, import_react.cloneElement)(rendered, mergeInjected(rendered.props, dom));
+}
+function renderSource(Component, overrides) {
+  const { dom, props } = splitInstanceOverrides(overrides);
+  const { key, ...domWithoutKey } = dom || {};
+  return (0, import_react.createElement)(
+    JucieInstance.Provider,
+    { value: domWithoutKey, key },
+    (0, import_react.createElement)(SourceInstance, { Component, props, dom: domWithoutKey })
+  );
+}
+
+export {
+  splitInstanceOverrides,
+  setup,
+  loadProjectMain,
+  provideJucie,
+  useJucie,
+  hostRootProps,
+  createRef,
+  createTrigger,
+  createHost,
+  JucieInstance,
+  mergeInjected,
+  JucieRoot,
+  Jucie,
+  defineJucieComponent,
+  renderSource,
+  react_exports,
+  import_react2 as import_react,
+  import_client2 as import_client
+};

package/dist/stage-bundles/react/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/react/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/react/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/react/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/react/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/react/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/react/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/react/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/react/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/react/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/react/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/react/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/react/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/react/chunks/chunk-IDGFZWZY.js

@@ -0,0 +1,13 @@
+// ../scene-graph/nodes/queries/findDescendantIds.js
+function findDescendantIds(state, id, descendantIds = []) {
+  const children = state.get([id, "children"]) || [];
+  for (const childId of children) {
+    descendantIds.push(childId);
+    descendantIds = findDescendantIds(state, childId, descendantIds);
+  }
+  return descendantIds;
+}
+
+export {
+  findDescendantIds
+};

package/dist/stage-bundles/react/chunks/chunk-IIIXGKVH.js

@@ -0,0 +1,17 @@
+import {
+  createOption
+} from "./chunk-FSIANI7E.js";
+
+// ../scene-graph/nodes/mutations/updateOption.js
+function updateOption(state, id, value, { value: newValue, label }) {
+  const option = createOption({ value: newValue, label });
+  const existing = state.findWhere([id, "options", "set"], { value });
+  if (existing === void 0) {
+    return state.push([id, "options", "set"], option);
+  }
+  return state.setWhere([id, "options", "set"], { value }, option);
+}
+
+export {
+  updateOption
+};

package/dist/stage-bundles/react/chunks/chunk-ILZWSEWK.js

@@ -0,0 +1,19 @@
+import {
+  createAction
+} from "./chunk-YCZNHFZA.js";
+
+// ../scene-graph/stores/mutations/addAction.js
+function addAction(state, id) {
+  return state.update([id, "actions"], (actions = []) => {
+    const actionName = `action${actions.length + 1}`;
+    if (actions.some((a) => a.name === actionName)) {
+      return actions;
+    }
+    actions.unshift(createAction({ name: actionName }));
+    return actions;
+  });
+}
+
+export {
+  addAction
+};

package/dist/stage-bundles/react/chunks/chunk-IO3NSIEJ.js

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

package/dist/stage-bundles/react/chunks/chunk-JDIO27MU.js

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