pixifact 0.1.3

package/dist/authoring/SceneDocument.js

@@ -0,0 +1,332 @@
+import EventEmitter from "eventemitter3";
+import { CommandStack } from "../commands/CommandStack.js";
+import { findNode } from "../commands/utils.js";
+import { emptySelection } from "./SceneSelection.js";
+import { buildInspectorModel } from "./InspectorModel.js";
+import { createRuntimePreview, destroyRuntimePreview } from "./RuntimePreview.js";
+import { lockKey } from "./OverrideJournal.js";
+import { createMemorySuggestions } from "./PreferenceMemory.js";
+import { isSceneProjectState } from "./SceneProjectState.js";
+import { upsertAction } from "./ActionRegistry.js";
+import { createLogicGraph, validateLogicGraph } from "./LogicGraph.js";
+function cloneScene(scene) {
+    return structuredClone(scene);
+}
+export class SceneDocument {
+    scene;
+    selection = emptySelection;
+    dirty = false;
+    emitter = new EventEmitter();
+    preview;
+    locks = [];
+    overrides = [];
+    memory = [];
+    designTokens;
+    actions = [];
+    logicGraph = createLogicGraph();
+    commandStack = new CommandStack();
+    previewContext;
+    previewParent;
+    constructor(scene) {
+        this.scene = cloneScene(scene);
+    }
+    apply(command, source = 'manual') {
+        const result = this.commandStack.execute(this.scene, command, {
+            actions: this.actions.length > 0 ? this.actions : undefined,
+        });
+        if (!result.ok) {
+            return result;
+        }
+        this.recordOverride(result, source);
+        this.dirty = true;
+        this.ensureSelectionValid();
+        this.rebuildPreview();
+        this.emitter.emit('changed', result);
+        return result;
+    }
+    addLock(lock) {
+        const key = lockKey(lock);
+        if (!this.locks.some((item) => lockKey(item) === key)) {
+            this.locks.push(lock);
+            this.dirty = true;
+        }
+    }
+    removeLock(lock) {
+        const key = lockKey(lock);
+        const previousLength = this.locks.length;
+        this.locks = this.locks.filter((item) => lockKey(item) !== key);
+        if (this.locks.length !== previousLength) {
+            this.dirty = true;
+        }
+    }
+    getMemorySuggestions() {
+        const accepted = new Set(this.memory.map((item) => item.context));
+        return createMemorySuggestions(this.overrides)
+            .filter((suggestion) => !accepted.has(suggestion.memory.context));
+    }
+    acceptMemorySuggestion(suggestion) {
+        if (!this.memory.some((item) => item.id === suggestion.memory.id || item.context === suggestion.memory.context)) {
+            this.memory.push(suggestion.memory);
+            this.dirty = true;
+        }
+    }
+    upsertMemory(memory) {
+        const existing = this.memory.find((item) => item.id === memory.id);
+        if (existing) {
+            Object.assign(existing, memory);
+        }
+        else {
+            this.memory.push(memory);
+        }
+        this.dirty = true;
+    }
+    setMemoryEnabled(id, enabled) {
+        const item = this.memory.find((memory) => memory.id === id);
+        if (item && item.enabled !== enabled) {
+            item.enabled = enabled;
+            this.dirty = true;
+        }
+    }
+    removeMemory(id) {
+        const previousLength = this.memory.length;
+        this.memory = this.memory.filter((memory) => memory.id !== id);
+        if (this.memory.length !== previousLength) {
+            this.dirty = true;
+        }
+    }
+    importMemory(memory, replace = false) {
+        if (replace) {
+            this.memory = structuredClone([...memory]);
+        }
+        else {
+            for (const item of memory) {
+                this.upsertMemory({
+                    ...structuredClone(item),
+                    source: item.source ?? 'imported',
+                });
+            }
+        }
+        this.dirty = true;
+    }
+    addAction(action) {
+        upsertAction(this.actions, action);
+        this.dirty = true;
+    }
+    removeAction(key) {
+        const previousLength = this.actions.length;
+        this.actions = this.actions.filter((action) => action.key !== key);
+        if (this.actions.length !== previousLength) {
+            this.dirty = true;
+        }
+    }
+    addLogicFlow(flow) {
+        const graph = structuredClone(this.logicGraph);
+        const index = graph.flows.findIndex((item) => item.id === flow.id);
+        if (index === -1) {
+            graph.flows.push(flow);
+        }
+        else {
+            graph.flows[index] = flow;
+        }
+        const validation = validateLogicGraph(graph, {
+            actions: this.actions.length > 0 ? this.actions : undefined,
+            scene: this.scene,
+        });
+        if (!validation.ok) {
+            return {
+                ok: false,
+                errors: validation.errors,
+            };
+        }
+        this.logicGraph = graph;
+        this.dirty = true;
+        return {
+            ok: true,
+            graph: this.logicGraph,
+        };
+    }
+    removeLogicFlow(id) {
+        const previousLength = this.logicGraph.flows.length;
+        this.logicGraph = {
+            ...this.logicGraph,
+            flows: this.logicGraph.flows.filter((flow) => flow.id !== id),
+        };
+        if (this.logicGraph.flows.length !== previousLength) {
+            this.dirty = true;
+        }
+    }
+    recordOverride(result, source) {
+        const command = result.command;
+        const inverse = result.inverse;
+        if (command.op === 'batch' && inverse.op === 'batch') {
+            for (let i = 0; i < command.commands.length; i++) {
+                const child = command.commands[i];
+                const inverseChild = inverse.commands[inverse.commands.length - 1 - i];
+                this.recordOverride({ ok: true, command: child, inverse: inverseChild }, source);
+            }
+            return;
+        }
+        if (command.op === 'setNodeProp' && inverse.op === 'setNodeProp') {
+            this.overrides.push({
+                source,
+                target: `${command.node}.${command.prop}`,
+                before: inverse.value,
+                after: command.value,
+                timestamp: Date.now(),
+            });
+        }
+        if (command.op === 'setComponentProp' && inverse.op === 'setComponentProp') {
+            this.overrides.push({
+                source,
+                target: `${command.node}.${command.component}.${command.prop}`,
+                before: inverse.value,
+                after: command.value,
+                timestamp: Date.now(),
+            });
+        }
+        if (command.op === 'setTransform' && inverse.op === 'setTransform') {
+            for (const [prop, after] of Object.entries(command.values)) {
+                this.overrides.push({
+                    source,
+                    target: `${command.node}.transform.${prop}`,
+                    before: inverse.values[prop],
+                    after,
+                    timestamp: Date.now(),
+                });
+            }
+        }
+        if (command.op === 'setNodeData' && inverse.op === 'setNodeData') {
+            this.overrides.push({
+                source,
+                target: `${command.node}.${command.field}.${command.prop}`,
+                before: inverse.value,
+                after: command.value,
+                timestamp: Date.now(),
+            });
+        }
+    }
+    undo() {
+        const result = this.commandStack.undo(this.scene, {
+            actions: this.actions.length > 0 ? this.actions : undefined,
+        });
+        if (result?.ok) {
+            this.dirty = true;
+            this.ensureSelectionValid();
+            this.rebuildPreview();
+            this.emitter.emit('changed', result);
+        }
+        return result;
+    }
+    redo() {
+        const result = this.commandStack.redo(this.scene, {
+            actions: this.actions.length > 0 ? this.actions : undefined,
+        });
+        if (result?.ok) {
+            this.dirty = true;
+            this.ensureSelectionValid();
+            this.rebuildPreview();
+            this.emitter.emit('changed', result);
+        }
+        return result;
+    }
+    get canUndo() {
+        return this.commandStack.canUndo;
+    }
+    get canRedo() {
+        return this.commandStack.canRedo;
+    }
+    setSelection(selection) {
+        this.selection = selection;
+        this.emitter.emit('selectionChanged', selection);
+    }
+    ensureSelectionValid() {
+        if (this.selection.type === 'none') {
+            return;
+        }
+        if (!findNode(this.scene, this.selection.node)) {
+            this.selection = emptySelection;
+            this.emitter.emit('selectionChanged', this.selection);
+        }
+    }
+    serialize() {
+        return JSON.stringify(this.scene, null, 2);
+    }
+    serializeState() {
+        return JSON.stringify(this.getState(), null, 2);
+    }
+    getState() {
+        return {
+            version: 1,
+            type: 'pixifact.aiEditorProject',
+            scene: cloneScene(this.scene),
+            selection: this.selection,
+            designTokens: this.designTokens ? structuredClone(this.designTokens) : undefined,
+            actions: structuredClone(this.actions),
+            logicGraph: structuredClone(this.logicGraph),
+            locks: structuredClone(this.locks),
+            overrides: structuredClone(this.overrides),
+            memory: structuredClone(this.memory),
+        };
+    }
+    load(json) {
+        const parsed = typeof json === 'string'
+            ? JSON.parse(json)
+            : json;
+        if (isSceneProjectState(parsed)) {
+            this.loadState(parsed);
+            return;
+        }
+        this.scene = cloneScene(parsed);
+        this.selection = emptySelection;
+        this.designTokens = undefined;
+        this.actions = [];
+        this.logicGraph = createLogicGraph();
+        this.locks = [];
+        this.overrides = [];
+        this.memory = [];
+        this.ensureSelectionValid();
+        this.dirty = false;
+        this.commandStack.clear();
+        this.rebuildPreview();
+        this.emitter.emit('loaded', this.scene);
+    }
+    loadState(state) {
+        this.scene = cloneScene(state.scene);
+        this.selection = state.selection ?? emptySelection;
+        this.designTokens = state.designTokens ? structuredClone(state.designTokens) : undefined;
+        this.actions = structuredClone(state.actions ?? []);
+        this.logicGraph = state.logicGraph ? structuredClone(state.logicGraph) : createLogicGraph();
+        this.locks = structuredClone(state.locks ?? []);
+        this.overrides = structuredClone(state.overrides ?? []);
+        this.memory = structuredClone(state.memory ?? []);
+        this.ensureSelectionValid();
+        this.dirty = false;
+        this.commandStack.clear();
+        this.rebuildPreview();
+        this.emitter.emit('loaded', this.scene);
+        this.emitter.emit('selectionChanged', this.selection);
+    }
+    rebuildPreview(context = this.previewContext, parent = this.previewParent) {
+        this.previewContext = context;
+        this.previewParent = parent;
+        destroyRuntimePreview(this.preview);
+        this.preview = createRuntimePreview(this.scene, parent, context);
+        this.emitter.emit('previewRebuilt', this.preview);
+        return this.preview;
+    }
+    getInspectorModel(node = this.selection.type === 'none' ? undefined : this.selection.node) {
+        if (!node) {
+            return undefined;
+        }
+        return buildInspectorModel(this.scene, node);
+    }
+    clearPreview() {
+        destroyRuntimePreview(this.preview);
+        this.preview = undefined;
+        this.previewParent = undefined;
+    }
+    destroy() {
+        this.clearPreview();
+        this.emitter.removeAllListeners();
+    }
+}

package/dist/authoring/SceneProjectState.d.ts

@@ -0,0 +1,20 @@
+import type { SceneSpec } from "../scene/index.js";
+import type { DesignTokenSpec } from "./DesignToken.js";
+import type { SceneSelection } from "./SceneSelection.js";
+import type { LockSpec, OverrideSpec } from "./OverrideJournal.js";
+import type { PreferenceMemory } from "./PreferenceMemory.js";
+import type { ActionSpec } from "./ActionRegistry.js";
+import type { LogicGraphSpec } from "./LogicGraph.js";
+export interface SceneProjectState {
+    version: 1;
+    type: 'pixifact.aiEditorProject';
+    scene: SceneSpec;
+    selection?: SceneSelection;
+    designTokens?: DesignTokenSpec;
+    actions: ActionSpec[];
+    logicGraph?: LogicGraphSpec;
+    locks: LockSpec[];
+    overrides: OverrideSpec[];
+    memory: PreferenceMemory[];
+}
+export declare function isSceneProjectState(value: unknown): value is SceneProjectState;

package/dist/authoring/SceneProjectState.js

@@ -0,0 +1,8 @@
+export function isSceneProjectState(value) {
+    return typeof value === 'object'
+        && value !== null
+        && value.type === 'pixifact.aiEditorProject'
+        && value.version === 1
+        && typeof value.scene === 'object'
+        && value.scene?.type === 'scene';
+}

package/dist/authoring/SceneSelection.d.ts

@@ -0,0 +1,11 @@
+export type SceneSelection = {
+    type: 'none';
+} | {
+    type: 'node';
+    node: string;
+} | {
+    type: 'component';
+    node: string;
+    component: string;
+};
+export declare const emptySelection: SceneSelection;

package/dist/authoring/SceneSelection.js

@@ -0,0 +1 @@
+export const emptySelection = { type: 'none' };

package/dist/authoring/index.d.ts

@@ -0,0 +1,13 @@
+export * from './SceneSelection.js';
+export * from './SceneDocument.js';
+export * from './RuntimePreview.js';
+export * from './InspectorModel.js';
+export * from './DesignToken.js';
+export * from './DiffModel.js';
+export * from './OverrideJournal.js';
+export * from './PreferenceMemory.js';
+export * from './SceneProjectState.js';
+export * from './ComponentPalette.js';
+export * from './ActionRegistry.js';
+export * from './LogicGraph.js';
+export * from './ProjectConfig.js';

package/dist/authoring/index.js

@@ -0,0 +1,13 @@
+export * from './SceneSelection.js';
+export * from './SceneDocument.js';
+export * from './RuntimePreview.js';
+export * from './InspectorModel.js';
+export * from './DesignToken.js';
+export * from './DiffModel.js';
+export * from './OverrideJournal.js';
+export * from './PreferenceMemory.js';
+export * from './SceneProjectState.js';
+export * from './ComponentPalette.js';
+export * from './ActionRegistry.js';
+export * from './LogicGraph.js';
+export * from './ProjectConfig.js';

package/dist/commands/Command.d.ts

@@ -0,0 +1,63 @@
+import type { ComponentSpec, NodeSpec, RectTransformSpec, SceneNodeKind } from "../scene/index.js";
+export interface SetNodePropCommand {
+    op: 'setNodeProp';
+    node: string;
+    prop: 'id' | 'key' | 'role' | 'name';
+    value: string | undefined;
+}
+export interface SetTransformCommand {
+    op: 'setTransform';
+    node: string;
+    values: Partial<RectTransformSpec>;
+}
+export interface SetNodeDataCommand {
+    op: 'setNodeData';
+    node: string;
+    field: Exclude<SceneNodeKind, 'container'>;
+    prop: string;
+    value: unknown;
+}
+export interface SetComponentPropCommand {
+    op: 'setComponentProp';
+    node: string;
+    component: string;
+    prop: string;
+    value: unknown;
+}
+export interface AddComponentCommand {
+    op: 'addComponent';
+    node: string;
+    component: ComponentSpec;
+    index?: number;
+}
+export interface RemoveComponentCommand {
+    op: 'removeComponent';
+    node: string;
+    component: string;
+}
+export interface CreateNodeCommand {
+    op: 'createNode';
+    parent?: string;
+    node: NodeSpec;
+    index?: number;
+}
+export interface DeleteNodeCommand {
+    op: 'deleteNode';
+    node: string;
+}
+export interface ReparentNodeCommand {
+    op: 'reparentNode';
+    node: string;
+    parent?: string;
+    index?: number;
+}
+export interface ReorderNodeCommand {
+    op: 'reorderNode';
+    node: string;
+    index: number;
+}
+export interface BatchCommand {
+    op: 'batch';
+    commands: SceneCommand[];
+}
+export type SceneCommand = SetNodePropCommand | SetTransformCommand | SetNodeDataCommand | SetComponentPropCommand | AddComponentCommand | RemoveComponentCommand | CreateNodeCommand | DeleteNodeCommand | ReparentNodeCommand | ReorderNodeCommand | BatchCommand;

package/dist/commands/Command.js

@@ -0,0 +1 @@
+export {};

package/dist/commands/CommandStack.d.ts

@@ -0,0 +1,14 @@
+import type { SceneSpec } from "../scene/index.js";
+import type { CommandResult } from "./applyCommand.js";
+import type { SceneCommand } from "./Command.js";
+import type { CommandValidationContext } from "./validateCommand.js";
+export declare class CommandStack {
+    private undoStack;
+    private redoStack;
+    get canUndo(): boolean;
+    get canRedo(): boolean;
+    execute(scene: SceneSpec, command: SceneCommand, context?: CommandValidationContext): CommandResult;
+    undo(scene: SceneSpec, context?: CommandValidationContext): CommandResult | undefined;
+    redo(scene: SceneSpec, context?: CommandValidationContext): CommandResult | undefined;
+    clear(): void;
+}

package/dist/commands/CommandStack.js

@@ -0,0 +1,45 @@
+import { applyCommand } from "./applyCommand.js";
+export class CommandStack {
+    undoStack = [];
+    redoStack = [];
+    get canUndo() {
+        return this.undoStack.length > 0;
+    }
+    get canRedo() {
+        return this.redoStack.length > 0;
+    }
+    execute(scene, command, context = {}) {
+        const result = applyCommand(scene, command, context);
+        if (result.ok) {
+            this.undoStack.push(result.inverse);
+            this.redoStack.length = 0;
+        }
+        return result;
+    }
+    undo(scene, context = {}) {
+        const command = this.undoStack.pop();
+        if (!command) {
+            return undefined;
+        }
+        const result = applyCommand(scene, command, context);
+        if (result.ok) {
+            this.redoStack.push(result.inverse);
+        }
+        return result;
+    }
+    redo(scene, context = {}) {
+        const command = this.redoStack.pop();
+        if (!command) {
+            return undefined;
+        }
+        const result = applyCommand(scene, command, context);
+        if (result.ok) {
+            this.undoStack.push(result.inverse);
+        }
+        return result;
+    }
+    clear() {
+        this.undoStack.length = 0;
+        this.redoStack.length = 0;
+    }
+}

package/dist/commands/applyCommand.d.ts

@@ -0,0 +1,23 @@
+import type { SceneSpec } from "../scene/index.js";
+import type { SceneCommand } from "./Command.js";
+import type { CommandValidationContext } from "./validateCommand.js";
+export type CommandResult = {
+    ok: true;
+    command: SceneCommand;
+    inverse: SceneCommand;
+} | {
+    ok: false;
+    command: SceneCommand;
+    error: string;
+};
+export interface CommandFailureDetails {
+    commandIndex?: number;
+    op?: SceneCommand['op'];
+    node?: string;
+    target?: string;
+    hint?: string;
+}
+export declare function hintForCommandError(error: string): "Use a project-relative scene path that stays inside projectRoot." | "Choose a different scene path or inspect the existing file before writing." | "Use one of: button, progressBar, scrollView, loginForm." | "Re-run scene get or node inspect to refresh locators before regenerating the command." | "Choose a container node as the parent, or create a container template before adding children." | "Verify that the field belongs to the target node or component schema before retrying." | "Check the target schema and send a value with the expected type." | undefined;
+export declare function commandFailureDetails(commands: SceneCommand[], results: CommandResult[], error: string | undefined): CommandFailureDetails;
+export declare function applyCommand(scene: SceneSpec, command: SceneCommand, context?: CommandValidationContext): CommandResult;
+export declare const applySceneCommand: typeof applyCommand;