@jucie.io/cli 1.0.0

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

@@ -0,0 +1,49 @@
+import {
+  createFrameOverrides
+} from "./chunk-6R3QXFFF.js";
+import {
+  createNode
+} from "./chunk-UFHA3ODE.js";
+import {
+  moveNodeToLastChildOf
+} from "./chunk-RHAVY7VB.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/vue/chunks/chunk-ISOZDDO2.js

@@ -0,0 +1,157 @@
+import {
+  createNode
+} from "./chunk-UFHA3ODE.js";
+import {
+  findDescendantIds
+} from "./chunk-IDGFZWZY.js";
+import {
+  nodeExists
+} from "./chunk-KOBPYD4N.js";
+import {
+  createNodeId
+} from "./chunk-S5L2YBXG.js";
+
+// ../scene-graph/nodes/operations/replaceNode.js
+function replaceNode(state, currentId, newId) {
+  if (!nodeExists(state, currentId) || !nodeExists(state, newId)) return false;
+  const nodePath = state.findWhen("children", "includes", currentId);
+  if (!nodePath) {
+    return false;
+  }
+  state.update(nodePath, (children = []) => children.map((child) => child === currentId ? newId : child));
+  return true;
+}
+
+// ../scene-graph/utils/clone.js
+var clone = (value) => {
+  if (structuredClone) {
+    return structuredClone(value);
+  } else {
+    return JSON.parse(JSON.stringify(value));
+  }
+};
+
+// ../scene-graph/nodes/operations/copyNode.js
+function copyNode(state, id) {
+  const descendantIds = findDescendantIds(state, id);
+  const ids = [id, ...descendantIds];
+  const nodes = {};
+  for (const id2 of ids) {
+    const node = state.get([id2]);
+    if (node) {
+      nodes[id2] = node;
+    }
+  }
+  return clone(nodes);
+}
+
+// ../scene-graph/nodes/operations/cloneNodes.js
+function cloneNodes(nodes) {
+  const oldIds = Object.keys(nodes);
+  const newNodes = {};
+  const idMapping = /* @__PURE__ */ new Map();
+  oldIds.forEach((oldId) => {
+    const newId = createNodeId();
+    idMapping.set(oldId, newId);
+  });
+  oldIds.forEach((oldId) => {
+    const newId = idMapping.get(oldId);
+    const node = nodes[oldId];
+    const clonedNode = { ...node };
+    if (clonedNode.children && Array.isArray(clonedNode.children)) {
+      clonedNode.children = clonedNode.children.map((childId) => idMapping.get(childId) || null).filter((id) => id !== null);
+    }
+    if (clonedNode.slots && Array.isArray(clonedNode.slots)) {
+      clonedNode.slots = clonedNode.slots.map((slot) => ({
+        ...slot,
+        id: idMapping.get(slot.id) ?? slot.id,
+        children: (slot.children || []).map((childId) => idMapping.get(childId) ?? childId)
+      }));
+    }
+    if (clonedNode.type === "frame") {
+      clonedNode.route = clonedNode.route ? { ...clonedNode.route, path: `${newId}` } : { path: `${newId}` };
+    }
+    newNodes[newId] = clonedNode;
+  });
+  const allIds = Object.keys(newNodes);
+  const referencedIds = /* @__PURE__ */ new Set();
+  Object.values(newNodes).forEach((node) => {
+    if (node.children && Array.isArray(node.children)) {
+      node.children.forEach((childId) => {
+        if (childId) referencedIds.add(childId);
+      });
+    }
+  });
+  const rootIds = allIds.filter((id) => !referencedIds.has(id));
+  return [rootIds, newNodes];
+}
+
+// ../scene-graph/nodes/operations/addComponent.js
+var EDGES = ["top", "left", "right", "bottom"];
+var POSITIONAL_PROPS = [...EDGES];
+function migratePositionalStyles(state, fromId, toId, anchor) {
+  const styleMap = state.get([fromId, "style"]);
+  if (!styleMap) return;
+  const anchorSet = new Set(anchor ?? []);
+  for (const bpKey in styleMap) {
+    const bpStyles = styleMap[bpKey];
+    if (!bpStyles || typeof bpStyles !== "object") continue;
+    const toMigrate = {};
+    let hasProps = false;
+    for (const edge of EDGES) {
+      if (edge in bpStyles && anchorSet.has(edge)) {
+        toMigrate[edge] = bpStyles[edge];
+        hasProps = true;
+      }
+    }
+    if (hasProps) {
+      state.update([toId, "style", bpKey], (current = {}) => ({ ...current, ...toMigrate }));
+      state.update([fromId, "style", bpKey], (current = {}) => {
+        const cleaned = { ...current };
+        for (const prop of POSITIONAL_PROPS) delete cleaned[prop];
+        return cleaned;
+      });
+    }
+  }
+}
+function addComponent(state, childId, name, bounds = null) {
+  const childPosition = state.get([childId, ".position"]);
+  const childAnchor = state.get([childId, "anchor"]);
+  const childDimensions = state.get([childId, "dimensions"]);
+  const snapshot = copyNode(state, childId);
+  const [clonedRootIds, clonedNodes] = cloneNodes(snapshot);
+  const clonedRootId = clonedRootIds[0];
+  for (const [id, node] of Object.entries(clonedNodes)) {
+    state.set([id], node);
+  }
+  const [componentId, component] = createNode("component", { children: [clonedRootId], name, bounds });
+  const [instanceId, instance] = createNode("instance", { component: componentId });
+  state.set([componentId], component);
+  state.set([instanceId], instance);
+  state.update(["components", "children"], (children = []) => {
+    if (children.indexOf(componentId) === -1) {
+      return [...children, componentId];
+    }
+    return children;
+  });
+  replaceNode(state, childId, instanceId);
+  const descendantIds = findDescendantIds(state, childId);
+  for (const id of descendantIds) {
+    state.remove([id]);
+  }
+  state.remove([childId]);
+  if (childPosition) state.set([instanceId, ".position"], childPosition);
+  if (childAnchor) state.set([instanceId, "anchor"], childAnchor);
+  if (childDimensions) state.set([instanceId, "dimensions"], childDimensions);
+  migratePositionalStyles(state, clonedRootId, instanceId, childAnchor);
+  state.set([clonedRootId, "isComponentRoot"], true);
+  state.set([clonedRootId, "anchor"], []);
+  return instanceId;
+}
+
+export {
+  clone,
+  copyNode,
+  cloneNodes,
+  addComponent
+};

package/dist/stage-bundles/vue/chunks/chunk-IVU4565D.js

@@ -0,0 +1,26 @@
+import {
+  canAcceptChildren
+} from "./chunk-K7ZULZJF.js";
+import {
+  createTextContent
+} from "./chunk-KHURU62K.js";
+
+// ../scene-graph/nodes/mutations/setTextContent.js
+function setTextContent(state, id, textContentInput) {
+  if (canAcceptChildren(state, id)) return;
+  let value = "";
+  let specificPatterns;
+  if (typeof textContentInput === "string") {
+    value = textContentInput;
+  } else if (textContentInput != null && typeof textContentInput === "object") {
+    value = textContentInput.value ?? "";
+    if (Object.prototype.hasOwnProperty.call(textContentInput, "specificPatterns")) {
+      specificPatterns = textContentInput.specificPatterns;
+    }
+  }
+  return state.set([id, "textContent"], createTextContent({ value, specificPatterns }));
+}
+
+export {
+  setTextContent
+};

package/dist/stage-bundles/vue/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
+};