@jucie.io/cli 1.0.0

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

@@ -0,0 +1,92 @@
+import {
+  canAcceptChildren
+} from "./chunk-K7ZULZJF.js";
+import {
+  nodeExists
+} from "./chunk-KOBPYD4N.js";
+import {
+  normalizeLayoutContext
+} from "./chunk-SKOTGWTH.js";
+
+// ../scene-graph/nodes/queries/getNodeLevel.js
+function getNodeLevel(state, id) {
+  if (!state.has([id])) return null;
+  const isRoot = state.get(["app", "children"])?.includes(id);
+  if (isRoot) return "root";
+  const isTemp = state.get(["temp", "children"])?.includes(id);
+  if (isTemp) return "temp";
+  const isComponentRoot = state.get(["components", "children"])?.includes(id);
+  if (isComponentRoot) return "components";
+  return "nested";
+}
+
+// ../scene-graph/nodes/validators/canMoveFrame.js
+function canMoveFrame(state, id, targetId, moveType) {
+  const node = state.get([id]);
+  if (!node || !node.bounds) {
+    return true;
+  }
+  if (moveType === "instance") {
+    return false;
+  }
+  const isComponent = node.type === "component";
+  if (moveType === "root" || moveType === "temp") {
+    return !isComponent;
+  }
+  if (moveType === "after" || moveType === "before") {
+    const targetLevel = getNodeLevel(state, targetId);
+    if (isComponent) {
+      return targetLevel === "components";
+    }
+    return targetLevel === "root" || targetLevel === "temp";
+  }
+  if (moveType === "firstChildOf" || moveType === "lastChildOf") {
+    if (isComponent) {
+      return targetId === "components";
+    }
+    return targetId === "app" || targetId === "temp";
+  }
+  return false;
+}
+
+// ../scene-graph/nodes/operations/moveNodeToRoot.js
+function moveNodeToRoot(state, id) {
+  state.update(["app", "children"], (children = []) => {
+    if (children.indexOf(id) === -1) {
+      return [...children, id];
+    }
+    return children;
+  });
+  normalizeLayoutContext(state, id, "app");
+  return true;
+}
+
+// ../scene-graph/nodes/operations/moveNodeToLastChildOf.js
+function moveNodeToLastChildOf(state, id, parent) {
+  if (!nodeExists(state, parent)) return;
+  if (!nodeExists(state, id)) return;
+  const childEx = state.get([id, "ex"]) ?? state.get([id, "type"]);
+  if (!canAcceptChildren(state, parent, childEx)) return;
+  if (!canMoveFrame(state, id, parent, "lastChildOf")) {
+    moveNodeToRoot(state, id);
+    return;
+  }
+  state.update([parent, "children"], (children = []) => {
+    const childIndex = children.indexOf(id);
+    if (childIndex !== -1) {
+      const newChildren = [...children];
+      newChildren.splice(childIndex, 1);
+      return [...newChildren, id];
+    }
+    return [...children, id];
+  });
+  normalizeLayoutContext(state, id, parent);
+  return true;
+}
+
+export {
+  getNodeLevel,
+  canMoveFrame,
+  moveNodeToRoot,
+  moveNodeToLastChildOf
+};

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

@@ -0,0 +1,10 @@
+// ../scene-graph/stores/factories/createCode.js
+function createCode() {
+  return `function () {
+  // Store state, computed, and actions are available on this
+}`;
+}
+
+export {
+  createCode
+};

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

@@ -0,0 +1,12 @@
+import {
+  createState
+} from "./chunk-6QYYO5LM.js";
+
+// ../scene-graph/nodes/mutations/updateState.js
+function updateState(state, id, name, stateEntry) {
+  return state.setWhere([id, "states"], { name }, createState(stateEntry));
+}
+
+export {
+  updateState
+};

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

@@ -0,0 +1,12 @@
+import {
+  createEvent
+} from "./chunk-M3YT4JBL.js";
+
+// ../scene-graph/nodes/mutations/updateEvent.js
+function updateEvent(state, id, name, event) {
+  return state.setWhere([id, "events"], { name }, createEvent(event));
+}
+
+export {
+  updateEvent
+};

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

@@ -0,0 +1,143 @@
+// ../../node_modules/nanoid/non-secure/index.js
+var urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
+var nanoid = (size = 21) => {
+  let id = "";
+  let i = size | 0;
+  while (i-- > 0) {
+    id += urlAlphabet[Math.random() * 64 | 0];
+  }
+  return id;
+};
+
+// ../scene-graph/id/id.js
+var globalScope = globalThis;
+var COUNTER_KEY = Symbol.for("\u26D4\uFE0Funique-id-counter");
+var SESSION_KEY = Symbol.for("\u26D4\uFE0Funique-id-session");
+if (!globalScope[COUNTER_KEY]) {
+  globalScope[COUNTER_KEY] = 0;
+}
+if (!globalScope[SESSION_KEY]) {
+  globalScope[SESSION_KEY] = Math.random().toString(36).slice(2, 6);
+}
+var generatedIds = /* @__PURE__ */ new Set();
+function createBaseId() {
+  const count = globalScope[COUNTER_KEY]++;
+  const rand = Math.random().toString(36).slice(2, 4);
+  return `${globalScope[SESSION_KEY]}${count}${rand}`;
+}
+function generateId(prefix = "", options = {}) {
+  const { short = false, length = 21, customLength = null } = options;
+  let id;
+  let attempts = 0;
+  const maxAttempts = 100;
+  do {
+    if (short) {
+      const baseId = createBaseId();
+      id = prefix ? `${prefix}_${baseId}` : baseId;
+    } else if (customLength) {
+      const baseId = nanoid(customLength);
+      id = prefix ? `${prefix}_${baseId}` : baseId;
+    } else {
+      const baseId = nanoid(length);
+      id = prefix ? `${prefix}_${baseId}` : baseId;
+    }
+    attempts++;
+    if (attempts > maxAttempts) {
+      throw new Error(`Failed to generate unique ID after ${maxAttempts} attempts`);
+    }
+  } while (generatedIds.has(id));
+  generatedIds.add(id);
+  return id;
+}
+var createId = (options = {}) => generateId("", { short: true, ...options });
+var createSceneId = (options = {}) => generateId("sc", options);
+var createSpaceId = (options = {}) => generateId("sp", options);
+var createAssetId = (options = {}) => generateId("as", options);
+var createChannelId = (options = {}) => generateId("ch", options);
+var createNodeId = (options = {}) => generateId("nd", { short: true, ...options });
+var createAnimationId = (options = {}) => generateId("anim", { short: true, ...options });
+var createTokenId = (options = {}) => generateId("tok", { short: true, ...options });
+var createActorId = (options = {}) => generateId("actor", options);
+var createDocumentId = (options = {}) => generateId("doc", options);
+var createPortId = (options = {}) => generateId("port", options);
+var createMessageRequestId = (options = {}) => generateId("msgReq", options);
+var createStoreId = (options = {}) => generateId("str", options);
+var createDescriptorId = (options = {}) => generateId("desc", options);
+var createLongId = (options = {}) => generateId("", { length: 32, ...options });
+var createUuid = (options = {}) => generateId("uuid", { customLength: 36, ...options });
+var createSecureId = (options = {}) => generateId("sec", { customLength: 64, ...options });
+function parseId(id) {
+  const [prefix] = id.split("_");
+  return {
+    type: prefix,
+    id
+  };
+}
+function isValidId(id, options = {}) {
+  const { short = false, length = 21, customLength = null } = options;
+  if (typeof id !== "string") {
+    return false;
+  }
+  if (!id.includes("_")) {
+    if (short) {
+      return id.length >= 10 && id.length <= 12;
+    }
+    return id.length === length;
+  }
+  const [prefix, hash] = id.split("_");
+  if (short) {
+    return hash.length >= 10 && hash.length <= 12;
+  }
+  if (customLength) {
+    return hash.length === customLength;
+  }
+  return hash.length === length;
+}
+function clearGeneratedIds() {
+  generatedIds.clear();
+}
+function getGeneratedIds() {
+  return Array.from(generatedIds);
+}
+function isIdGenerated(id) {
+  return generatedIds.has(id);
+}
+function removeGeneratedId(id) {
+  return generatedIds.delete(id);
+}
+function loadExistingIds(ids) {
+  if (!Array.isArray(ids)) return;
+  ids.forEach((id) => {
+    if (typeof id === "string") {
+      generatedIds.add(id);
+    }
+  });
+  globalScope[COUNTER_KEY] = generatedIds.size;
+}
+
+export {
+  createId,
+  createSceneId,
+  createSpaceId,
+  createAssetId,
+  createChannelId,
+  createNodeId,
+  createAnimationId,
+  createTokenId,
+  createActorId,
+  createDocumentId,
+  createPortId,
+  createMessageRequestId,
+  createStoreId,
+  createDescriptorId,
+  createLongId,
+  createUuid,
+  createSecureId,
+  parseId,
+  isValidId,
+  clearGeneratedIds,
+  getGeneratedIds,
+  isIdGenerated,
+  removeGeneratedId,
+  loadExistingIds
+};

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

@@ -0,0 +1,14 @@
+// ../scene-graph/nodes/factories/createDestination.js
+function createDestination({ path = null, target = null, id = null, type = "url", replace = false, params = [], query = null }) {
+  return { path, target, id, type, replace, params, query };
+}
+
+// ../scene-graph/nodes/mutations/setDestination.js
+function setDestination(state, id, destination = {}) {
+  return state.set([id, "destination"], createDestination(destination));
+}
+
+export {
+  createDestination,
+  setDestination
+};

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

@@ -0,0 +1,140 @@
+import {
+  updateBounds
+} from "./chunk-22J4JOPG.js";
+import {
+  updateStyle
+} from "./chunk-W7QH4UII.js";
+
+// ../scene-graph/nodes/validators/getLayoutContext.js
+function getLayoutContext(state, nodeId) {
+  const layout = state.get([nodeId, "layout"]);
+  if (layout && layout !== "none") return layout;
+  const display = state.get([nodeId, "style", "default", "display"]);
+  if (display === "flex" || display === "grid") return display;
+  return "none";
+}
+
+// ../scene-graph/nodes/mutations/stripStyleProperties.js
+function stripStyleProperties(state, id, properties) {
+  const styleMap = state.get([id, "style"]);
+  if (!styleMap || !properties.length) return;
+  for (const bpKey in styleMap) {
+    const bpStyles = styleMap[bpKey];
+    if (!bpStyles || typeof bpStyles !== "object") continue;
+    for (const prop of properties) {
+      if (prop in bpStyles) state.remove([id, "style", bpKey, prop]);
+    }
+    for (const stateKey in bpStyles) {
+      if (!stateKey.startsWith(":") && !stateKey.startsWith("&.")) continue;
+      const stateStyles = bpStyles[stateKey];
+      if (!stateStyles || typeof stateStyles !== "object") continue;
+      for (const prop of properties) {
+        if (prop in stateStyles) state.remove([id, "style", bpKey, stateKey, prop]);
+      }
+    }
+  }
+}
+
+// ../scene-graph/nodes/mutations/stripPositionalStyles.js
+var POSITIONAL = ["top", "left", "right", "bottom"];
+function stripPositionalStyles(state, id) {
+  stripStyleProperties(state, id, POSITIONAL);
+}
+
+// ../scene-graph/nodes/mutations/defaultNodeBehavior.js
+function defaultNodeBehavior() {
+  return {
+    layout: "none",
+    draggable: true,
+    resizable: true,
+    selectable: true,
+    locked: [],
+    anchor: [],
+    dimensions: [],
+    expandedStyles: [],
+    childrenType: "children"
+  };
+}
+
+// ../scene-graph/utils/arrayDiff.js
+function arrayDiff(oldArr, newArr) {
+  if (!oldArr) return [];
+  if (!newArr) return oldArr;
+  return oldArr.filter((item) => !newArr.includes(item));
+}
+
+// ../scene-graph/nodes/mutations/updateAnchor.js
+function updateAnchor(state, id, newAnchor) {
+  const oldAnchor = state.get([id, "anchor"]);
+  const removed = arrayDiff(oldAnchor, newAnchor);
+  if (removed.length) stripStyleProperties(state, id, removed);
+  state.set([id, "anchor"], newAnchor);
+  return true;
+}
+
+// ../scene-graph/nodes/mutations/clearPosition.js
+function clearPosition(state, id) {
+  return state.set([id, ".position"], null);
+}
+
+// ../scene-graph/nodes/mutations/applyNodePatch.js
+function applyNodePatch(nodes, id, patch, breakpoint) {
+  if (!patch || typeof patch !== "object") return;
+  const keys = Object.keys(patch).sort();
+  for (const key of keys) {
+    const value = patch[key];
+    switch (key) {
+      case "style": {
+        const anchor = patch?.anchor;
+        updateStyle(nodes, id, value, { breakpoint, anchor });
+        clearPosition(nodes, id);
+        break;
+      }
+      case "bounds":
+        updateBounds(nodes, id, value);
+        break;
+      case "anchor":
+        updateAnchor(nodes, id, value);
+        break;
+      default:
+        nodes.set([id, key], value);
+        break;
+    }
+  }
+}
+function setNodeBehavior(nodes, id, updates = {}) {
+  const merged = { ...defaultNodeBehavior(), ...updates };
+  for (const key of Object.keys(merged)) {
+    nodes.set([id, key], merged[key]);
+  }
+}
+function resetNodeBehavior(nodes, id) {
+  const d = defaultNodeBehavior();
+  for (const key of Object.keys(d)) {
+    nodes.set([id, key], d[key]);
+  }
+  nodes.set([id, "hidden"], void 0);
+  nodes.set([id, "isComponentRoot"], void 0);
+}
+
+// ../scene-graph/nodes/mutations/normalizeLayoutContext.js
+function normalizeLayoutContext(state, nodeId, targetParentId) {
+  const parentInFlow = getLayoutContext(state, targetParentId) !== "none";
+  if (parentInFlow) {
+    stripPositionalStyles(state, nodeId);
+    applyNodePatch(state, nodeId, { anchor: [], dimensions: [] });
+    return;
+  }
+  const anchor = state.get([nodeId, "anchor"]);
+  if (!anchor || !anchor.length) {
+    applyNodePatch(state, nodeId, { anchor: ["top", "left"], dimensions: ["width", "height"] });
+  }
+}
+
+export {
+  clearPosition,
+  applyNodePatch,
+  setNodeBehavior,
+  resetNodeBehavior,
+  normalizeLayoutContext
+};

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

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

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

@@ -0,0 +1,35 @@
+import {
+  removeAttribute
+} from "./chunk-VZNGMF63.js";
+import {
+  createDescriptor
+} from "./chunk-H75SQT4U.js";
+
+// ../scene-graph/nodes/factories/createAttribute.js
+function createAttribute({ name, mode, ...rest } = {}) {
+  return createDescriptor({ name, mode: mode ?? "value", ...rest });
+}
+
+// ../scene-graph/nodes/mutations/clearValueChannelConflict.js
+var VALUE_CHANNEL = /* @__PURE__ */ new Set(["model", "value", "checked"]);
+function clearValueChannelConflict(state, id, nextName) {
+  if (!VALUE_CHANNEL.has(nextName)) return [];
+  const toRemove = nextName === "model" ? ["value", "checked"] : ["model"];
+  const cleared = [];
+  for (const name of toRemove) {
+    const attrs = state.get([id, "attributes"]) ?? [];
+    if (attrs.some((a) => a.name === name)) {
+      removeAttribute(state, id, name);
+      cleared.push(name);
+    }
+  }
+  if (state.get([id, "model"]) != null) {
+    state.set([id, "model"], null);
+  }
+  return cleared;
+}
+
+export {
+  createAttribute,
+  clearValueChannelConflict
+};

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

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

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

@@ -0,0 +1,18 @@
+// ../scene-graph/nodes/factories/createRoute.js
+function createRoute({ path = null, params = [] } = {}) {
+  return { path, params };
+}
+
+// ../scene-graph/nodes/mutations/updateRoute.js
+function updateRoute(state, id, route) {
+  return state.update([id, "route"], (currentRoute = {}) => {
+    return createRoute({
+      ...currentRoute,
+      ...route
+    });
+  });
+}
+
+export {
+  updateRoute
+};

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

@@ -0,0 +1,31 @@
+import {
+  hasExpression,
+  parseDependencies,
+  parseExpression
+} from "./chunk-AI3MQHWR.js";
+
+// ../scene-graph/nodes/mutations/setOptionsExpression.js
+function parseField(value) {
+  const expression = hasExpression(value) ? parseExpression(value) : null;
+  return {
+    value: (value ?? "").trim(),
+    expression,
+    dependencies: expression ? parseDependencies(expression) : []
+  };
+}
+function setOptionsExpression(state, id, { binding, valueKey, labelKey }) {
+  const bindingExpression = hasExpression(binding) ? parseExpression(binding) : null;
+  return state.update([id, "options"], (options = {}) => ({
+    ...options,
+    type: "binding",
+    binding: binding ?? options.binding,
+    expression: bindingExpression ?? options.expression,
+    dependencies: bindingExpression ? parseDependencies(bindingExpression) : options.dependencies ?? [],
+    valueKey: valueKey !== void 0 ? parseField(valueKey) : options.valueKey ?? parseField("value"),
+    labelKey: labelKey !== void 0 ? parseField(labelKey) : options.labelKey ?? parseField("label")
+  }));
+}
+
+export {
+  setOptionsExpression
+};