pixifact 0.1.3 → 0.1.4

package/dist/commands/applyCommand.js

@@ -1,316 +0,0 @@
-import { validateCommand } from "./validateCommand.js";
-import { cloneValue, findComponent, findNode } from "./utils.js";
-export function hintForCommandError(error) {
-    if (error.includes('inside projectRoot')) {
-        return 'Use a project-relative scene path that stays inside projectRoot.';
-    }
-    if (error.includes('already exists')) {
-        return 'Choose a different scene path or inspect the existing file before writing.';
-    }
-    if (error.includes('Unknown template kind')) {
-        return 'Use one of: button, progressBar, scrollView, loginForm.';
-    }
-    if (error.includes('was not found')) {
-        return 'Re-run scene get or node inspect to refresh locators before regenerating the command.';
-    }
-    if (error.includes('Only container nodes')) {
-        return 'Choose a container node as the parent, or create a container template before adding children.';
-    }
-    if (error.includes('does not exist')) {
-        return 'Verify that the field belongs to the target node or component schema before retrying.';
-    }
-    if (error.includes('expects')) {
-        return 'Check the target schema and send a value with the expected type.';
-    }
-    return undefined;
-}
-function commandNode(command) {
-    switch (command.op) {
-        case 'createNode':
-            return nodeLocator(command.node);
-        case 'batch':
-            return undefined;
-        default:
-            return command.node;
-    }
-}
-function commandTarget(command) {
-    switch (command.op) {
-        case 'setNodeProp':
-            return `${command.node}.${command.prop}`;
-        case 'setTransform':
-            return `${command.node}.transform`;
-        case 'setNodeData':
-            return `${command.node}.${command.field}.${command.prop}`;
-        case 'setComponentProp':
-            return `${command.node}.${command.component}.${command.prop}`;
-        case 'addComponent':
-            return `${command.node}.components.${command.component.id ?? command.component.type}`;
-        case 'removeComponent':
-            return `${command.node}.components.${command.component}`;
-        case 'createNode':
-            return `${command.parent ?? 'root'}.children`;
-        case 'deleteNode':
-            return command.node;
-        case 'reparentNode':
-            return `${command.node}.parent`;
-        case 'reorderNode':
-            return `${command.node}.index`;
-        case 'batch':
-            return 'batch.commands';
-    }
-}
-export function commandFailureDetails(commands, results, error) {
-    const failedResultIndex = results.findIndex((result) => !result.ok);
-    const commandIndex = failedResultIndex >= 0
-        ? failedResultIndex
-        : Math.min(results.length, commands.length - 1);
-    const command = commands[commandIndex];
-    if (!command) {
-        return {
-            hint: error ? hintForCommandError(error) : undefined,
-        };
-    }
-    return {
-        commandIndex,
-        op: command.op,
-        node: commandNode(command),
-        target: commandTarget(command),
-        hint: error ? hintForCommandError(error) : undefined,
-    };
-}
-function applySetTransform(scene, command) {
-    const located = findNode(scene, command.node);
-    const previous = {};
-    const transform = located.node.transform ?? {};
-    for (const key of Object.keys(command.values)) {
-        previous[key] = transform[key];
-    }
-    located.node.transform = { ...transform };
-    for (const [key, value] of Object.entries(command.values)) {
-        if (value === undefined) {
-            delete located.node.transform[key];
-        }
-        else {
-            located.node.transform[key] = value;
-        }
-    }
-    return {
-        op: 'setTransform',
-        node: command.node,
-        values: previous,
-    };
-}
-function applySetNodeData(scene, command) {
-    const located = findNode(scene, command.node);
-    const nodeData = located.node;
-    const current = nodeData[command.field] ?? {};
-    const previous = current[command.prop];
-    const next = { ...current };
-    if (command.value === undefined) {
-        delete next[command.prop];
-    }
-    else {
-        next[command.prop] = cloneValue(command.value);
-    }
-    nodeData[command.field] = next;
-    return {
-        op: 'setNodeData',
-        node: command.node,
-        field: command.field,
-        prop: command.prop,
-        value: previous,
-    };
-}
-function applySetNodeProp(scene, command) {
-    const located = findNode(scene, command.node);
-    const previous = located.node[command.prop];
-    if (command.value === undefined) {
-        delete located.node[command.prop];
-    }
-    else {
-        located.node[command.prop] = command.value;
-    }
-    return {
-        op: 'setNodeProp',
-        node: command.value ?? command.node,
-        prop: command.prop,
-        value: previous,
-    };
-}
-function applySetComponentProp(scene, command) {
-    const locatedNode = findNode(scene, command.node);
-    const locatedComponent = findComponent(locatedNode.node, command.component);
-    const props = locatedComponent.component.props ?? {};
-    const previous = props[command.prop];
-    locatedComponent.component.props = { ...props };
-    if (command.value === undefined) {
-        delete locatedComponent.component.props[command.prop];
-    }
-    else {
-        locatedComponent.component.props[command.prop] = cloneValue(command.value);
-    }
-    return {
-        op: 'setComponentProp',
-        node: command.node,
-        component: command.component,
-        prop: command.prop,
-        value: previous,
-    };
-}
-function applyAddComponent(scene, command) {
-    const locatedNode = findNode(scene, command.node);
-    const components = locatedNode.node.components ?? [];
-    const index = command.index ?? components.length;
-    components.splice(index, 0, cloneValue(command.component));
-    locatedNode.node.components = components;
-    return {
-        op: 'removeComponent',
-        node: command.node,
-        component: command.component.id ?? command.component.type,
-    };
-}
-function applyRemoveComponent(scene, command) {
-    const locatedNode = findNode(scene, command.node);
-    const locatedComponent = findComponent(locatedNode.node, command.component);
-    const components = locatedNode.node.components ?? [];
-    const [removed] = components.splice(locatedComponent.index, 1);
-    locatedNode.node.components = components;
-    return {
-        op: 'addComponent',
-        node: command.node,
-        component: cloneValue(removed),
-        index: locatedComponent.index,
-    };
-}
-function applyCreateNode(scene, command) {
-    const children = command.parent
-        ? (findNode(scene, command.parent).node.children ??= [])
-        : (scene.root.children ??= []);
-    const index = command.index ?? children.length;
-    children.splice(index, 0, cloneValue(command.node));
-    return {
-        op: 'deleteNode',
-        node: command.node.id ?? command.node.key ?? command.node.name ?? '',
-    };
-}
-function applyDeleteNode(scene, command) {
-    const located = findNode(scene, command.node);
-    const siblings = located.parent?.children ?? [];
-    const [removed] = siblings.splice(located.index, 1);
-    return {
-        op: 'createNode',
-        parent: located.parent?.id ?? located.parent?.key ?? located.parent?.name,
-        node: cloneValue(removed),
-        index: located.index,
-    };
-}
-function nodeLocator(node) {
-    return node.id ?? node.key ?? node.name ?? '';
-}
-function applyReparentNode(scene, command) {
-    const located = findNode(scene, command.node);
-    const previousParent = located.parent;
-    const previousIndex = located.index;
-    const oldSiblings = previousParent?.children ?? [];
-    const [node] = oldSiblings.splice(previousIndex, 1);
-    const nextParent = command.parent ? findNode(scene, command.parent).node : scene.root;
-    const nextSiblings = nextParent.children ??= [];
-    const index = Math.min(command.index ?? nextSiblings.length, nextSiblings.length);
-    nextSiblings.splice(index, 0, node);
-    return {
-        op: 'reparentNode',
-        node: command.node,
-        parent: previousParent ? nodeLocator(previousParent) : undefined,
-        index: previousIndex,
-    };
-}
-function applyReorderNode(scene, command) {
-    const located = findNode(scene, command.node);
-    const siblings = located.parent.children ?? [];
-    const previousIndex = located.index;
-    const [node] = siblings.splice(previousIndex, 1);
-    const index = Math.min(command.index, siblings.length);
-    siblings.splice(index, 0, node);
-    return {
-        op: 'reorderNode',
-        node: command.node,
-        index: previousIndex,
-    };
-}
-function applyBatch(scene, command, context) {
-    const inverseCommands = [];
-    for (const child of command.commands) {
-        const result = applyCommand(scene, child, context);
-        if (!result.ok) {
-            for (let i = inverseCommands.length - 1; i >= 0; i--) {
-                applyCommand(scene, inverseCommands[i], context);
-            }
-            return {
-                ok: false,
-                command,
-                error: result.error,
-            };
-        }
-        inverseCommands.push(result.inverse);
-    }
-    return {
-        ok: true,
-        command,
-        inverse: {
-            op: 'batch',
-            commands: [...inverseCommands].reverse(),
-        },
-    };
-}
-export function applyCommand(scene, command, context = {}) {
-    const validation = validateCommand(scene, command, context);
-    if (!validation.ok) {
-        return {
-            ok: false,
-            command,
-            error: validation.error ?? 'Command validation failed.',
-        };
-    }
-    let inverse;
-    switch (command.op) {
-        case 'setNodeProp':
-            inverse = applySetNodeProp(scene, command);
-            break;
-        case 'setTransform':
-            inverse = applySetTransform(scene, command);
-            break;
-        case 'setNodeData':
-            inverse = applySetNodeData(scene, command);
-            break;
-        case 'setComponentProp':
-            inverse = applySetComponentProp(scene, command);
-            break;
-        case 'addComponent':
-            inverse = applyAddComponent(scene, command);
-            break;
-        case 'removeComponent':
-            inverse = applyRemoveComponent(scene, command);
-            break;
-        case 'createNode':
-            inverse = applyCreateNode(scene, command);
-            break;
-        case 'deleteNode':
-            inverse = applyDeleteNode(scene, command);
-            break;
-        case 'reparentNode':
-            inverse = applyReparentNode(scene, command);
-            break;
-        case 'reorderNode':
-            inverse = applyReorderNode(scene, command);
-            break;
-        case 'batch':
-            return applyBatch(scene, command, context);
-    }
-    return {
-        ok: true,
-        command,
-        inverse,
-    };
-}
-export const applySceneCommand = applyCommand;

package/dist/commands/index.d.ts

@@ -1,4 +0,0 @@
-export * from './Command.js';
-export * from './CommandStack.js';
-export * from './applyCommand.js';
-export * from './validateCommand.js';

package/dist/commands/index.js

@@ -1,4 +0,0 @@
-export * from './Command.js';
-export * from './CommandStack.js';
-export * from './applyCommand.js';
-export * from './validateCommand.js';

package/dist/commands/utils.d.ts

@@ -1,17 +0,0 @@
-import type { ComponentSpec, ContainerNodeSpec, NodeSpec, SceneSpec } from "../scene/index.js";
-export interface LocatedNode {
-    node: NodeSpec;
-    parent?: ContainerNodeSpec;
-    index: number;
-}
-export interface LocatedComponent {
-    component: ComponentSpec;
-    index: number;
-}
-export declare function cloneValue<T>(value: T): T;
-export declare function findNode(scene: SceneSpec, locator: string): LocatedNode | undefined;
-export declare function findComponent(node: NodeSpec, locator: string): LocatedComponent | undefined;
-export declare function hasDuplicateNodeId(scene: SceneSpec, id: string): boolean;
-export declare function hasDuplicateNodeLocator(scene: SceneSpec, locator: string, except?: NodeSpec): boolean;
-export declare function isDescendant(candidate: NodeSpec, parent: NodeSpec): boolean;
-export declare function hasDuplicateComponentId(node: NodeSpec, id: string): boolean;

package/dist/commands/utils.js

@@ -1,77 +0,0 @@
-export function cloneValue(value) {
-    return structuredClone(value);
-}
-function nodeMatches(node, locator) {
-    return node.id === locator || node.key === locator || node.name === locator;
-}
-export function findNode(scene, locator) {
-    const visit = (node, parent, index) => {
-        if (nodeMatches(node, locator)) {
-            return { node, parent, index };
-        }
-        if (node.kind === 'container') {
-            for (let i = 0; i < (node.children?.length ?? 0); i++) {
-                const child = node.children[i];
-                const found = visit(child, node, i);
-                if (found) {
-                    return found;
-                }
-            }
-        }
-        return undefined;
-    };
-    return visit(scene.root, undefined, 0);
-}
-export function findComponent(node, locator) {
-    const components = node.components ?? [];
-    for (let i = 0; i < components.length; i++) {
-        const component = components[i];
-        if (component.id === locator || component.type === locator) {
-            return { component, index: i };
-        }
-    }
-    return undefined;
-}
-export function hasDuplicateNodeId(scene, id) {
-    let count = 0;
-    const visit = (node) => {
-        if (node.id === id) {
-            count++;
-        }
-        if (node.kind === 'container') {
-            for (const child of node.children ?? []) {
-                visit(child);
-            }
-        }
-    };
-    visit(scene.root);
-    return count > 0;
-}
-export function hasDuplicateNodeLocator(scene, locator, except) {
-    let count = 0;
-    const visit = (node) => {
-        if (node !== except && (node.id === locator || node.key === locator || node.name === locator)) {
-            count++;
-        }
-        if (node.kind === 'container') {
-            for (const child of node.children ?? []) {
-                visit(child);
-            }
-        }
-    };
-    visit(scene.root);
-    return count > 0;
-}
-export function isDescendant(candidate, parent) {
-    if (parent.kind === 'container') {
-        for (const child of parent.children ?? []) {
-            if (child === candidate || isDescendant(candidate, child)) {
-                return true;
-            }
-        }
-    }
-    return false;
-}
-export function hasDuplicateComponentId(node, id) {
-    return (node.components ?? []).some((component) => component.id === id);
-}

package/dist/commands/validateCommand.d.ts

@@ -1,12 +0,0 @@
-import type { SceneSpec } from "../scene/index.js";
-import type { SceneCommand } from "./Command.js";
-import type { ActionSpec } from "../authoring/ActionRegistry.js";
-export interface ValidationResult {
-    ok: boolean;
-    error?: string;
-}
-export interface CommandValidationContext {
-    actions?: readonly ActionSpec[];
-}
-export declare function validateCommand(scene: SceneSpec, command: SceneCommand, context?: CommandValidationContext): ValidationResult;
-export declare const validateSceneCommand: typeof validateCommand;