@decido/shell 4.0.2 → 4.0.3

package/dist/chunk-UHT6FIYF.mjs

@@ -0,0 +1,195 @@
+import {
+  dlog
+} from "./chunk-3P4P3M54.mjs";
+
+// src/store/useMorphInstanceStore.ts
+import { create } from "zustand";
+import { persist } from "zustand/middleware";
+var useMorphInstanceStore = create()(
+  persist(
+    (set, get) => ({
+      instances: /* @__PURE__ */ new Map(),
+      activeInstanceId: null,
+      historyByInstance: /* @__PURE__ */ new Map(),
+      upsertInstance: (partial) => {
+        dlog.store(`upsertInstance: ${partial.id} (${partial.shellType})`, { id: partial.id, shellType: partial.shellType, label: partial.label });
+        set((state) => {
+          const instances = new Map(state.instances);
+          const existing = instances.get(partial.id);
+          const historyByInstance = new Map(state.historyByInstance);
+          if (existing?.data) {
+            const hist = historyByInstance.get(partial.id) || { stack: [], index: -1 };
+            const trimmed = hist.stack.slice(0, hist.index + 1);
+            trimmed.push({ ...existing.data });
+            if (trimmed.length > 20) trimmed.shift();
+            historyByInstance.set(partial.id, { stack: trimmed, index: trimmed.length - 1 });
+          }
+          instances.set(partial.id, {
+            artifacts: [],
+            activeArtifactIndex: 0,
+            createdAt: Date.now(),
+            ...existing,
+            ...partial
+          });
+          return { instances, activeInstanceId: partial.id, historyByInstance };
+        });
+      },
+      removeInstance: (id) => {
+        set((state) => {
+          const instances = new Map(state.instances);
+          instances.delete(id);
+          const activeInstanceId = state.activeInstanceId === id ? instances.size > 0 ? instances.keys().next().value ?? null : null : state.activeInstanceId;
+          return { instances, activeInstanceId };
+        });
+      },
+      setActiveInstance: (id) => set({ activeInstanceId: id }),
+      pushArtifact: (instanceId, artifact) => {
+        set((state) => {
+          const instances = new Map(state.instances);
+          const instance = instances.get(instanceId);
+          if (!instance) return state;
+          const newArtifact = { ...artifact, updatedAt: Date.now() };
+          const artifacts = [...instance.artifacts, newArtifact];
+          instances.set(instanceId, {
+            ...instance,
+            artifacts,
+            activeArtifactIndex: artifacts.length - 1
+          });
+          return { instances };
+        });
+      },
+      updateArtifact: (instanceId, artifactId, data) => {
+        set((state) => {
+          const instances = new Map(state.instances);
+          const instance = instances.get(instanceId);
+          if (!instance) return state;
+          const artifacts = instance.artifacts.map(
+            (a) => a.id === artifactId ? { ...a, data: { ...a.data, ...data }, updatedAt: Date.now() } : a
+          );
+          instances.set(instanceId, { ...instance, artifacts });
+          return { instances };
+        });
+      },
+      setActiveArtifact: (instanceId, index) => {
+        set((state) => {
+          const instances = new Map(state.instances);
+          const instance = instances.get(instanceId);
+          if (!instance) return state;
+          instances.set(instanceId, {
+            ...instance,
+            activeArtifactIndex: Math.max(0, Math.min(index, instance.artifacts.length - 1))
+          });
+          return { instances };
+        });
+      },
+      removeArtifact: (instanceId, artifactId) => {
+        set((state) => {
+          const instances = new Map(state.instances);
+          const instance = instances.get(instanceId);
+          if (!instance) return state;
+          const artifacts = instance.artifacts.filter((a) => a.id !== artifactId);
+          instances.set(instanceId, {
+            ...instance,
+            artifacts,
+            activeArtifactIndex: Math.min(instance.activeArtifactIndex, Math.max(0, artifacts.length - 1))
+          });
+          return { instances };
+        });
+      },
+      getInstance: (id) => get().instances.get(id),
+      getInstances: () => Array.from(get().instances.values()),
+      getActiveInstance: () => {
+        const { instances, activeInstanceId } = get();
+        return activeInstanceId ? instances.get(activeInstanceId) : void 0;
+      },
+      // Sprint AL: Undo/Redo
+      undo: (instanceId) => {
+        const id = instanceId || get().activeInstanceId;
+        if (!id) return;
+        set((state) => {
+          const hist = state.historyByInstance.get(id);
+          if (!hist || hist.index < 0) return state;
+          const instances = new Map(state.instances);
+          const inst = instances.get(id);
+          if (!inst) return state;
+          const historyByInstance = new Map(state.historyByInstance);
+          const restoredData = hist.stack[hist.index];
+          dlog.store(`undo: ${id} \u2192 version ${hist.index}/${hist.stack.length}`, { instanceId: id });
+          instances.set(id, { ...inst, data: { ...restoredData } });
+          historyByInstance.set(id, { ...hist, index: hist.index - 1 });
+          return { instances, historyByInstance };
+        });
+      },
+      redo: (instanceId) => {
+        const id = instanceId || get().activeInstanceId;
+        if (!id) return;
+        set((state) => {
+          const hist = state.historyByInstance.get(id);
+          if (!hist || hist.index >= hist.stack.length - 1) return state;
+          const instances = new Map(state.instances);
+          const inst = instances.get(id);
+          if (!inst) return state;
+          const historyByInstance = new Map(state.historyByInstance);
+          const nextIndex = hist.index + 1;
+          const restoredData = hist.stack[nextIndex];
+          dlog.store(`redo: ${id} \u2192 version ${nextIndex + 1}/${hist.stack.length}`, { instanceId: id });
+          instances.set(id, { ...inst, data: { ...restoredData } });
+          historyByInstance.set(id, { ...hist, index: nextIndex });
+          return { instances, historyByInstance };
+        });
+      },
+      canUndo: (instanceId) => {
+        const id = instanceId || get().activeInstanceId;
+        if (!id) return false;
+        const hist = get().historyByInstance.get(id);
+        return !!hist && hist.index >= 0;
+      },
+      canRedo: (instanceId) => {
+        const id = instanceId || get().activeInstanceId;
+        if (!id) return false;
+        const hist = get().historyByInstance.get(id);
+        return !!hist && hist.index < hist.stack.length - 1;
+      },
+      getHistoryInfo: (instanceId) => {
+        const id = instanceId || get().activeInstanceId;
+        if (!id) return { current: 0, total: 0 };
+        const hist = get().historyByInstance.get(id);
+        if (!hist) return { current: 0, total: 0 };
+        return { current: hist.index + 2, total: hist.stack.length + 1 };
+      }
+    }),
+    {
+      name: "decido-morph-instances",
+      storage: {
+        getItem: (name) => {
+          const raw = localStorage.getItem(name);
+          if (!raw) return null;
+          const parsed = JSON.parse(raw);
+          if (parsed.state?.instances) {
+            parsed.state.instances = new Map(parsed.state.instances);
+          }
+          return parsed;
+        },
+        setItem: (name, value) => {
+          const toStore = {
+            ...value,
+            state: {
+              ...value.state,
+              instances: Array.from(value.state.instances.entries())
+            }
+          };
+          localStorage.setItem(name, JSON.stringify(toStore));
+        },
+        removeItem: (name) => localStorage.removeItem(name)
+      },
+      partialize: (state) => ({
+        instances: state.instances,
+        activeInstanceId: state.activeInstanceId
+      })
+    }
+  )
+);
+
+export {
+  useMorphInstanceStore
+};

package/dist/chunk-UJCSKKID.mjs

@@ -0,0 +1,30 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+export {
+  __commonJS,
+  __toESM
+};