pixifact 0.1.3

package/dist/commands/validateCommand.js

@@ -0,0 +1,285 @@
+import { ComponentRegistry } from "../runtime/index.js";
+import { findComponent, findNode, hasDuplicateComponentId, hasDuplicateNodeId, isDescendant } from "./utils.js";
+import { actionExists } from "../authoring/ActionRegistry.js";
+function ok() {
+    return { ok: true };
+}
+function fail(error) {
+    return { ok: false, error };
+}
+function canContainChildNode(node, root) {
+    return node === root || node.kind === 'container';
+}
+function validateChildParent(parent, root) {
+    return canContainChildNode(parent, root)
+        ? ok()
+        : fail('Only container nodes can contain child nodes.');
+}
+function validateNodeSpec(node) {
+    if (!['container', 'image', 'text', 'input', 'shape'].includes(node.kind)) {
+        return fail('Node kind must be one of: container, image, text, input, shape.');
+    }
+    if (node.kind !== 'container' && Array.isArray(node.children) && node.children.length > 0) {
+        return fail('Only container nodes can declare children.');
+    }
+    if (node.kind === 'container') {
+        for (const child of node.children ?? []) {
+            const result = validateNodeSpec(child);
+            if (!result.ok) {
+                return result;
+            }
+        }
+    }
+    return ok();
+}
+function validateValue(prop, value, context = {}) {
+    if (value === undefined) {
+        return ok();
+    }
+    switch (prop.type) {
+        case 'number':
+        case 'color':
+            return typeof value === 'number' ? ok() : fail(`Prop "${prop.key}" expects a number.`);
+        case 'string':
+            return typeof value === 'string' ? ok() : fail(`Prop "${prop.key}" expects a string.`);
+        case 'event':
+            if (typeof value !== 'string') {
+                return fail(`Prop "${prop.key}" expects an action key string.`);
+            }
+            if (context.actions && !actionExists(context.actions, value)) {
+                return fail(`Action "${value}" is not declared in the project action registry.`);
+            }
+            return ok();
+        case 'assetRef':
+        case 'nodeRef':
+        case 'componentRef':
+            return typeof value === 'string' || (typeof value === 'object' && value !== null)
+                ? ok()
+                : fail(`Prop "${prop.key}" expects a reference or string value.`);
+        case 'boolean':
+            return typeof value === 'boolean' ? ok() : fail(`Prop "${prop.key}" expects a boolean.`);
+        case 'enum':
+            return prop.options?.includes(value)
+                ? ok()
+                : fail(`Prop "${prop.key}" expects one of: ${(prop.options ?? []).join(', ')}.`);
+        case 'vec2':
+        case 'rect':
+            return typeof value === 'object' && value !== null ? ok() : fail(`Prop "${prop.key}" expects an object.`);
+        default:
+            return ok();
+    }
+}
+function displayProp(type, key, options) {
+    return {
+        key,
+        type,
+        options,
+    };
+}
+const nodeDataProps = {
+    image: [
+        displayProp('enum', 'mode', ['sprite', 'nineSlice']),
+        displayProp('assetRef', 'src'),
+        displayProp('color', 'tint'),
+        displayProp('number', 'leftWidth'),
+        displayProp('number', 'rightWidth'),
+        displayProp('number', 'topHeight'),
+        displayProp('number', 'bottomHeight'),
+    ],
+    text: [
+        displayProp('string', 'value'),
+        displayProp('color', 'color'),
+        displayProp('number', 'fontSize'),
+        displayProp('string', 'fontFamily'),
+        displayProp('enum', 'fontWeight', ['normal', 'bold', 'bolder', 'lighter', '100', '200', '300', '400', '500', '600', '700', '800', '900']),
+        displayProp('boolean', 'center'),
+    ],
+    input: [
+        displayProp('string', 'value'),
+        displayProp('color', 'backgroundColor'),
+        displayProp('color', 'borderColor'),
+        displayProp('number', 'borderSize'),
+        displayProp('string', 'textColor'),
+        displayProp('number', 'fontSize'),
+        displayProp('string', 'fontFamily'),
+        displayProp('number', 'paddingLeft'),
+        displayProp('number', 'paddingRight'),
+        displayProp('number', 'paddingTop'),
+        displayProp('number', 'paddingBottom'),
+    ],
+    shape: [
+        displayProp('enum', 'type', ['rect', 'roundedRect']),
+        displayProp('color', 'color'),
+        displayProp('number', 'fillAlpha'),
+        displayProp('number', 'radius'),
+        displayProp('color', 'strokeColor'),
+        displayProp('number', 'strokeWidth'),
+        displayProp('number', 'strokeAlpha'),
+    ],
+};
+function validateSetNodeData(scene, command) {
+    const locatedNode = findNode(scene, command.node);
+    if (!locatedNode) {
+        return fail(`Node "${command.node}" was not found.`);
+    }
+    if (locatedNode.node.kind !== command.field) {
+        return fail(`Node "${command.node}" is ${locatedNode.node.kind}, not ${command.field}.`);
+    }
+    const prop = nodeDataProps[command.field].find((candidate) => candidate.key === command.prop);
+    if (!prop) {
+        return fail(`Node data prop "${command.prop}" does not exist on ${command.field}.`);
+    }
+    return validateValue(prop, command.value);
+}
+function validateComponentSpec(component, context = {}) {
+    const schema = ComponentRegistry.get(component.type);
+    if (!schema) {
+        return fail(`Unknown component type "${component.type}".`);
+    }
+    for (const [key, value] of Object.entries(component.props ?? {})) {
+        const prop = schema.props.find((candidate) => candidate.key === key);
+        if (!prop) {
+            return fail(`Prop "${key}" does not exist on ${component.type}.`);
+        }
+        const result = validateValue(prop, value, context);
+        if (!result.ok) {
+            return result;
+        }
+    }
+    return ok();
+}
+function validateSetComponentProp(scene, command, context = {}) {
+    const locatedNode = findNode(scene, command.node);
+    if (!locatedNode) {
+        return fail(`Node "${command.node}" was not found.`);
+    }
+    const locatedComponent = findComponent(locatedNode.node, command.component);
+    if (!locatedComponent) {
+        return fail(`Component "${command.component}" was not found on node "${command.node}".`);
+    }
+    const schema = ComponentRegistry.get(locatedComponent.component.type);
+    if (!schema) {
+        return fail(`Unknown component type "${locatedComponent.component.type}".`);
+    }
+    const prop = schema.props.find((candidate) => candidate.key === command.prop);
+    if (!prop) {
+        return fail(`Prop "${command.prop}" does not exist on ${schema.type}.`);
+    }
+    return validateValue(prop, command.value, context);
+}
+function validateAddComponent(scene, command, context = {}) {
+    const locatedNode = findNode(scene, command.node);
+    if (!locatedNode) {
+        return fail(`Node "${command.node}" was not found.`);
+    }
+    const result = validateComponentSpec(command.component, context);
+    if (!result.ok) {
+        return result;
+    }
+    const schema = ComponentRegistry.get(command.component.type);
+    if (schema?.disallowMultiple && (locatedNode.node.components ?? []).some((component) => component.type === command.component.type)) {
+        return fail(`Component "${command.component.type}" cannot be added more than once.`);
+    }
+    if (command.component.id && hasDuplicateComponentId(locatedNode.node, command.component.id)) {
+        return fail(`Component id "${command.component.id}" already exists on node "${command.node}".`);
+    }
+    return ok();
+}
+function validateSetNodeProp(scene, command) {
+    const locatedNode = findNode(scene, command.node);
+    if (!locatedNode) {
+        return fail(`Node "${command.node}" was not found.`);
+    }
+    if (command.value !== undefined && typeof command.value !== 'string') {
+        return fail(`Node prop "${command.prop}" expects a string.`);
+    }
+    if (command.prop === 'id' && command.value) {
+        const duplicate = findNode(scene, command.value);
+        if (duplicate && duplicate.node !== locatedNode.node) {
+            return fail(`Node id "${command.value}" already exists.`);
+        }
+    }
+    return ok();
+}
+function validateReparentNode(scene, command) {
+    const locatedNode = findNode(scene, command.node);
+    if (!locatedNode) {
+        return fail(`Node "${command.node}" was not found.`);
+    }
+    if (locatedNode.node === scene.root) {
+        return fail('Root node cannot be reparented.');
+    }
+    const parent = command.parent ? findNode(scene, command.parent) : undefined;
+    if (command.parent && !parent) {
+        return fail(`Parent node "${command.parent}" was not found.`);
+    }
+    if (parent && (parent.node === locatedNode.node || isDescendant(parent.node, locatedNode.node))) {
+        return fail(`Node "${command.node}" cannot be reparented under itself or its descendant.`);
+    }
+    return validateChildParent(parent?.node ?? scene.root, scene.root);
+}
+function validateReorderNode(scene, command) {
+    const locatedNode = findNode(scene, command.node);
+    if (!locatedNode) {
+        return fail(`Node "${command.node}" was not found.`);
+    }
+    if (!locatedNode.parent) {
+        return fail('Root node cannot be reordered.');
+    }
+    if (!Number.isInteger(command.index) || command.index < 0) {
+        return fail('Reorder index must be a non-negative integer.');
+    }
+    return ok();
+}
+export function validateCommand(scene, command, context = {}) {
+    switch (command.op) {
+        case 'setNodeProp':
+            return validateSetNodeProp(scene, command);
+        case 'setTransform':
+            return findNode(scene, command.node) ? ok() : fail(`Node "${command.node}" was not found.`);
+        case 'setNodeData':
+            return validateSetNodeData(scene, command);
+        case 'setComponentProp':
+            return validateSetComponentProp(scene, command, context);
+        case 'addComponent':
+            return validateAddComponent(scene, command, context);
+        case 'removeComponent': {
+            const locatedNode = findNode(scene, command.node);
+            if (!locatedNode) {
+                return fail(`Node "${command.node}" was not found.`);
+            }
+            return findComponent(locatedNode.node, command.component)
+                ? ok()
+                : fail(`Component "${command.component}" was not found on node "${command.node}".`);
+        }
+        case 'createNode':
+            const parent = command.parent ? findNode(scene, command.parent) : undefined;
+            if (command.parent && !parent) {
+                return fail(`Parent node "${command.parent}" was not found.`);
+            }
+            {
+                const result = validateNodeSpec(command.node);
+                if (!result.ok) {
+                    return result;
+                }
+            }
+            if (command.node.id && hasDuplicateNodeId(scene, command.node.id)) {
+                return fail(`Node id "${command.node.id}" already exists.`);
+            }
+            return validateChildParent(parent?.node ?? scene.root, scene.root);
+        case 'deleteNode':
+            if (scene.root.id === command.node || scene.root.key === command.node || scene.root.name === command.node) {
+                return fail('Root node cannot be deleted.');
+            }
+            return findNode(scene, command.node) ? ok() : fail(`Node "${command.node}" was not found.`);
+        case 'reparentNode':
+            return validateReparentNode(scene, command);
+        case 'reorderNode':
+            return validateReorderNode(scene, command);
+        case 'batch':
+            return Array.isArray(command.commands) ? ok() : fail('Batch command expects a commands array.');
+        default:
+            return fail('Unknown command.');
+    }
+}
+export const validateSceneCommand = validateCommand;

package/dist/compiler/commands/index.d.ts

@@ -0,0 +1,109 @@
+import type { SceneTemplate, SceneTemplateInterface, SceneTemplateNode, SceneTemplateValue } from '../spec.js';
+export type CompilerSceneSelection = {
+    type: 'scene';
+} | {
+    type: 'node';
+    node: string;
+};
+export type CompilerSceneCommand = {
+    op: 'setSceneName';
+    value: string;
+} | {
+    op: 'setSceneProp';
+    prop: string;
+    value?: SceneTemplateValue;
+} | {
+    op: 'setNodeId';
+    node: string;
+    value?: string;
+} | {
+    op: 'setNodeProp';
+    node: string;
+    prop: string;
+    value?: SceneTemplateValue;
+} | {
+    op: 'setNodeEvent';
+    node: string;
+    event: string;
+    value?: string;
+} | {
+    op: 'renameSlotOutlet';
+    node: string;
+    name: string;
+} | {
+    op: 'insertNode';
+    parent: string;
+    index?: number;
+    node: SceneTemplateNode;
+} | {
+    op: 'deleteNode';
+    node: string;
+} | {
+    op: 'moveNode';
+    node: string;
+    parent: string;
+    index: number;
+} | {
+    op: 'batch';
+    commands: CompilerSceneCommand[];
+};
+export type CompilerSceneCommandResult = {
+    ok: true;
+    command: CompilerSceneCommand;
+    inverse: CompilerSceneCommand;
+    selection?: CompilerSceneSelection;
+} | {
+    ok: false;
+    command: CompilerSceneCommand;
+    error: string;
+};
+export interface CompilerSceneCommandContext {
+    sceneInterfaces?: Record<string, SceneTemplateInterface>;
+}
+export interface CompilerSceneCommandStackOptions {
+    label?: string;
+    mergeKey?: string;
+}
+export declare function compilerSceneNodeLocator(node: SceneTemplateNode, path?: string): string;
+export declare function applyCompilerSceneCommand(template: SceneTemplate, command: CompilerSceneCommand, context?: CompilerSceneCommandContext): CompilerSceneCommandResult;
+export declare class CompilerSceneCommandStack {
+    private undoStack;
+    private redoStack;
+    private currentRevision;
+    private savedRevision;
+    get canUndo(): boolean;
+    get canRedo(): boolean;
+    get dirty(): boolean;
+    execute(template: SceneTemplate, command: CompilerSceneCommand, options?: CompilerSceneCommandStackOptions, context?: CompilerSceneCommandContext): {
+        ok: true;
+        command: CompilerSceneCommand;
+        inverse: CompilerSceneCommand;
+        selection?: CompilerSceneSelection;
+    } | {
+        ok: false;
+        command: CompilerSceneCommand;
+        error: string;
+    };
+    undo(template: SceneTemplate, context?: CompilerSceneCommandContext): {
+        ok: true;
+        command: CompilerSceneCommand;
+        inverse: CompilerSceneCommand;
+        selection?: CompilerSceneSelection;
+    } | {
+        ok: false;
+        command: CompilerSceneCommand;
+        error: string;
+    } | undefined;
+    redo(template: SceneTemplate, context?: CompilerSceneCommandContext): {
+        ok: true;
+        command: CompilerSceneCommand;
+        inverse: CompilerSceneCommand;
+        selection?: CompilerSceneSelection;
+    } | {
+        ok: false;
+        command: CompilerSceneCommand;
+        error: string;
+    } | undefined;
+    markSaved(): void;
+    clear(): void;
+}