pixifact 0.1.3

package/dist/compiler/commands/index.js

@@ -0,0 +1,492 @@
+import { pixiSceneNodeAcceptsChildren } from '../pixiNodeSchema.js';
+function cloneNode(node) {
+    return structuredClone(node);
+}
+export function compilerSceneNodeLocator(node, path = '') {
+    const suffix = node.kind === 'slotOutlet'
+        ? `slot:${node.name}`
+        : node.id ?? (node.kind === 'sceneInstance' ? `${node.type}:${node.scene}` : node.type);
+    if (path) {
+        return `${path}:${suffix}`;
+    }
+    if (node.kind === 'slotOutlet') {
+        return suffix;
+    }
+    return suffix;
+}
+function childCompilerSceneNodeLocator(parentLocator, node, index) {
+    return compilerSceneNodeLocator(node, parentLocator === '__scene__' ? String(index) : `${parentLocator}/${index}`);
+}
+function normalizeSlotOutletName(value) {
+    return value.trim() || 'default';
+}
+function sceneInstanceHasSlot(node, slot, context) {
+    return node.slots[slot] !== undefined
+        || context.sceneInterfaces?.[node.scene]?.slots[slot] !== undefined;
+}
+function canInsertNodeIntoParent(parentLocator, child, acceptsSlotOutlet) {
+    if (child.kind === 'slotOutlet') {
+        return parentLocator !== '__scene__' && acceptsSlotOutlet;
+    }
+    return true;
+}
+function findCompilerSceneNodeLocation(nodes, locator, context, parentLocator = '__scene__', acceptsSlotOutlet = false) {
+    for (const [index, node] of nodes.entries()) {
+        const nodeLocator = childCompilerSceneNodeLocator(parentLocator, node, index);
+        if (nodeLocator === locator) {
+            return {
+                acceptsSlotOutlet,
+                index,
+                locator: nodeLocator,
+                node,
+                nodes,
+                parentLocator,
+            };
+        }
+        if (node.kind === 'pixi') {
+            const found = findCompilerSceneNodeLocation(node.children, locator, context, nodeLocator, pixiSceneNodeAcceptsChildren(node.type));
+            if (found) {
+                return found;
+            }
+            continue;
+        }
+        if (node.kind === 'sceneInstance') {
+            for (const [slot, children] of Object.entries(node.slots)) {
+                const found = findCompilerSceneNodeLocation(children, locator, context, `${nodeLocator}/slot:${slot}`, false);
+                if (found) {
+                    return found;
+                }
+            }
+        }
+    }
+    return undefined;
+}
+function directSlotName(ownerLocator, locator) {
+    const prefix = `${ownerLocator}/slot:`;
+    if (!locator.startsWith(prefix)) {
+        return undefined;
+    }
+    const rest = locator.slice(prefix.length);
+    return rest.includes('/') ? undefined : rest;
+}
+function findCompilerSceneChildList(nodes, parent, context, parentLocator = '__scene__') {
+    if (parentLocator === '__scene__' && parent === '__scene__') {
+        return {
+            acceptsSlotOutlet: false,
+            index: nodes.length,
+            nodes,
+            parentLocator: '__scene__',
+        };
+    }
+    for (const [index, node] of nodes.entries()) {
+        const nodeLocator = childCompilerSceneNodeLocator(parentLocator, node, index);
+        if (node.kind === 'pixi') {
+            if (nodeLocator === parent) {
+                return pixiSceneNodeAcceptsChildren(node.type)
+                    ? {
+                        acceptsSlotOutlet: true,
+                        index: node.children.length,
+                        nodes: node.children,
+                        parentLocator: nodeLocator,
+                    }
+                    : undefined;
+            }
+            const found = findCompilerSceneChildList(node.children, parent, context, nodeLocator);
+            if (found) {
+                return found;
+            }
+            continue;
+        }
+        if (node.kind === 'sceneInstance') {
+            const slot = directSlotName(nodeLocator, parent);
+            if (slot) {
+                if (!sceneInstanceHasSlot(node, slot, context)) {
+                    return undefined;
+                }
+                const children = node.slots[slot] ?? [];
+                node.slots[slot] = children;
+                return {
+                    acceptsSlotOutlet: false,
+                    index: children.length,
+                    nodes: children,
+                    parentLocator: parent,
+                };
+            }
+            for (const [slotName, children] of Object.entries(node.slots)) {
+                const found = findCompilerSceneChildList(children, parent, context, `${nodeLocator}/slot:${slotName}`);
+                if (found) {
+                    return found;
+                }
+            }
+        }
+    }
+    return undefined;
+}
+function findCompilerSceneNodeLocator(nodes, target, parentLocator = '__scene__') {
+    for (const [index, node] of nodes.entries()) {
+        const nodeLocator = childCompilerSceneNodeLocator(parentLocator, node, index);
+        if (node === target) {
+            return nodeLocator;
+        }
+        if (node.kind === 'pixi') {
+            const found = findCompilerSceneNodeLocator(node.children, target, nodeLocator);
+            if (found) {
+                return found;
+            }
+            continue;
+        }
+        if (node.kind === 'sceneInstance') {
+            for (const [slot, children] of Object.entries(node.slots)) {
+                const found = findCompilerSceneNodeLocator(children, target, `${nodeLocator}/slot:${slot}`);
+                if (found) {
+                    return found;
+                }
+            }
+        }
+    }
+    return undefined;
+}
+function setSceneName(template, command) {
+    const previous = template.name;
+    template.name = command.value;
+    return {
+        ok: true,
+        command,
+        inverse: {
+            op: 'setSceneName',
+            value: previous,
+        },
+        selection: { type: 'scene' },
+    };
+}
+function setSceneProp(template, command) {
+    const previous = getPropPathValue(template.props, command.prop);
+    setPropPathValue(template.props, command.prop, command.value);
+    return {
+        ok: true,
+        command,
+        inverse: {
+            op: 'setSceneProp',
+            prop: command.prop,
+            value: previous,
+        },
+        selection: { type: 'scene' },
+    };
+}
+function setNodeId(template, command, context) {
+    const located = findCompilerSceneNodeLocation(template.children, command.node, context);
+    if (!located || located.node.kind === 'slotOutlet') {
+        return { ok: false, command, error: 'Node was not found.' };
+    }
+    const previous = located.node.id;
+    located.node.id = command.value?.trim() || undefined;
+    const locator = childCompilerSceneNodeLocator(located.parentLocator, located.node, located.index);
+    return {
+        ok: true,
+        command,
+        inverse: {
+            op: 'setNodeId',
+            node: locator,
+            value: previous,
+        },
+        selection: { type: 'node', node: locator },
+    };
+}
+function setNodeProp(template, command, context) {
+    const located = findCompilerSceneNodeLocation(template.children, command.node, context);
+    if (!located || located.node.kind === 'slotOutlet') {
+        return { ok: false, command, error: 'Node was not found.' };
+    }
+    const previous = getPropPathValue(located.node.props, command.prop);
+    setPropPathValue(located.node.props, command.prop, command.value);
+    return {
+        ok: true,
+        command,
+        inverse: {
+            op: 'setNodeProp',
+            node: command.node,
+            prop: command.prop,
+            value: previous,
+        },
+        selection: { type: 'node', node: command.node },
+    };
+}
+function getPropPathValue(props, prop) {
+    const [root, field, ...rest] = prop.split('.');
+    if (!field || rest.length > 0) {
+        return props[prop];
+    }
+    const value = props[root];
+    return value && typeof value === 'object' ? value[field] : undefined;
+}
+function setPropPathValue(props, prop, value) {
+    const [root, field, ...rest] = prop.split('.');
+    if (!field || rest.length > 0) {
+        if (value === undefined) {
+            delete props[prop];
+        }
+        else {
+            props[prop] = value;
+        }
+        return;
+    }
+    const current = props[root];
+    const objectValue = current && typeof current === 'object'
+        ? { ...current }
+        : {};
+    if (value === undefined) {
+        delete objectValue[field];
+    }
+    else if (typeof value !== 'object') {
+        objectValue[field] = value;
+    }
+    if (Object.keys(objectValue).length === 0) {
+        delete props[root];
+    }
+    else {
+        props[root] = objectValue;
+    }
+}
+function setNodeEvent(template, command, context) {
+    const located = findCompilerSceneNodeLocation(template.children, command.node, context);
+    if (!located || located.node.kind !== 'sceneInstance') {
+        return { ok: false, command, error: 'Node event target was not found.' };
+    }
+    const previous = located.node.events[command.event];
+    if (command.value === undefined) {
+        delete located.node.events[command.event];
+    }
+    else {
+        located.node.events[command.event] = command.value;
+    }
+    return {
+        ok: true,
+        command,
+        inverse: {
+            op: 'setNodeEvent',
+            node: command.node,
+            event: command.event,
+            value: previous,
+        },
+        selection: { type: 'node', node: command.node },
+    };
+}
+function renameSlotOutlet(template, command, context) {
+    const located = findCompilerSceneNodeLocation(template.children, command.node, context);
+    if (!located || located.node.kind !== 'slotOutlet') {
+        return { ok: false, command, error: 'Slot outlet was not found.' };
+    }
+    const previous = located.node.name;
+    located.node.name = normalizeSlotOutletName(command.name);
+    const locator = childCompilerSceneNodeLocator(located.parentLocator, located.node, located.index);
+    return {
+        ok: true,
+        command,
+        inverse: {
+            op: 'renameSlotOutlet',
+            node: locator,
+            name: previous,
+        },
+        selection: { type: 'node', node: locator },
+    };
+}
+function insertNode(template, command, context) {
+    const childList = findCompilerSceneChildList(template.children, command.parent, context);
+    if (!childList || !canInsertNodeIntoParent(command.parent, command.node, childList.acceptsSlotOutlet)) {
+        return { ok: false, command, error: 'Parent cannot contain this node.' };
+    }
+    const node = cloneNode(command.node);
+    const index = Math.max(0, Math.min(command.index ?? childList.nodes.length, childList.nodes.length));
+    childList.nodes.splice(index, 0, node);
+    const locator = childCompilerSceneNodeLocator(command.parent, node, index);
+    return {
+        ok: true,
+        command,
+        inverse: {
+            op: 'deleteNode',
+            node: locator,
+        },
+        selection: { type: 'node', node: locator },
+    };
+}
+function deleteNode(template, command, context) {
+    const located = findCompilerSceneNodeLocation(template.children, command.node, context);
+    if (!located) {
+        return { ok: false, command, error: 'Node was not found.' };
+    }
+    const [removed] = located.nodes.splice(located.index, 1);
+    return {
+        ok: true,
+        command,
+        inverse: {
+            op: 'insertNode',
+            parent: located.parentLocator,
+            index: located.index,
+            node: cloneNode(removed),
+        },
+        selection: located.parentLocator === '__scene__'
+            ? { type: 'scene' }
+            : { type: 'node', node: located.parentLocator },
+    };
+}
+function moveNode(template, command, context) {
+    if (command.parent === command.node || command.parent.startsWith(`${command.node}/`)) {
+        return { ok: false, command, error: 'Cannot move a node into itself.' };
+    }
+    const source = findCompilerSceneNodeLocation(template.children, command.node, context);
+    const target = findCompilerSceneChildList(template.children, command.parent, context);
+    if (!source || !target || !canInsertNodeIntoParent(command.parent, source.node, target.acceptsSlotOutlet)) {
+        return { ok: false, command, error: 'Target cannot contain this node.' };
+    }
+    const [node] = source.nodes.splice(source.index, 1);
+    let index = Math.max(0, Math.min(command.index, target.nodes.length));
+    if (source.nodes === target.nodes && source.index < index) {
+        index -= 1;
+    }
+    target.nodes.splice(index, 0, node);
+    const locator = findCompilerSceneNodeLocator(template.children, node);
+    if (!locator) {
+        throw new Error('Moved Compiler Scene node is missing from the template.');
+    }
+    return {
+        ok: true,
+        command,
+        inverse: {
+            op: 'moveNode',
+            node: locator,
+            parent: source.parentLocator,
+            index: source.index,
+        },
+        selection: { type: 'node', node: locator },
+    };
+}
+function applyBatch(template, command, context) {
+    const inverseCommands = [];
+    let selection;
+    for (const child of command.commands) {
+        const result = applyCompilerSceneCommand(template, child, context);
+        if (!result.ok) {
+            for (let index = inverseCommands.length - 1; index >= 0; index--) {
+                applyCompilerSceneCommand(template, inverseCommands[index], context);
+            }
+            return {
+                ok: false,
+                command,
+                error: result.error,
+            };
+        }
+        inverseCommands.push(result.inverse);
+        selection = result.selection;
+    }
+    return {
+        ok: true,
+        command,
+        inverse: {
+            op: 'batch',
+            commands: [...inverseCommands].reverse(),
+        },
+        selection,
+    };
+}
+export function applyCompilerSceneCommand(template, command, context = {}) {
+    switch (command.op) {
+        case 'setSceneName':
+            return setSceneName(template, command);
+        case 'setSceneProp':
+            return setSceneProp(template, command);
+        case 'setNodeId':
+            return setNodeId(template, command, context);
+        case 'setNodeProp':
+            return setNodeProp(template, command, context);
+        case 'setNodeEvent':
+            return setNodeEvent(template, command, context);
+        case 'renameSlotOutlet':
+            return renameSlotOutlet(template, command, context);
+        case 'insertNode':
+            return insertNode(template, command, context);
+        case 'deleteNode':
+            return deleteNode(template, command, context);
+        case 'moveNode':
+            return moveNode(template, command, context);
+        case 'batch':
+            return applyBatch(template, command, context);
+    }
+}
+export class CompilerSceneCommandStack {
+    undoStack = [];
+    redoStack = [];
+    currentRevision = 0;
+    savedRevision = 0;
+    get canUndo() {
+        return this.undoStack.length > 0;
+    }
+    get canRedo() {
+        return this.redoStack.length > 0;
+    }
+    get dirty() {
+        return this.currentRevision !== this.savedRevision;
+    }
+    execute(template, command, options = {}, context = {}) {
+        const beforeRevision = this.currentRevision;
+        const result = applyCompilerSceneCommand(template, command, context);
+        if (!result.ok) {
+            return result;
+        }
+        this.currentRevision += 1;
+        const previous = this.undoStack[this.undoStack.length - 1];
+        if (options.mergeKey && previous?.mergeKey === options.mergeKey) {
+            previous.command = command;
+            previous.afterRevision = this.currentRevision;
+            previous.label = options.label ?? previous.label;
+        }
+        else {
+            this.undoStack.push({
+                afterRevision: this.currentRevision,
+                beforeRevision,
+                command,
+                inverse: result.inverse,
+                label: options.label,
+                mergeKey: options.mergeKey,
+            });
+        }
+        this.redoStack.length = 0;
+        return result;
+    }
+    undo(template, context = {}) {
+        const entry = this.undoStack.pop();
+        if (!entry) {
+            return undefined;
+        }
+        const result = applyCompilerSceneCommand(template, entry.inverse, context);
+        if (!result.ok) {
+            this.undoStack.push(entry);
+            return result;
+        }
+        this.currentRevision = entry.beforeRevision;
+        this.redoStack.push(entry);
+        return result;
+    }
+    redo(template, context = {}) {
+        const entry = this.redoStack.pop();
+        if (!entry) {
+            return undefined;
+        }
+        const result = applyCompilerSceneCommand(template, entry.command, context);
+        if (!result.ok) {
+            this.redoStack.push(entry);
+            return result;
+        }
+        this.currentRevision = entry.afterRevision;
+        this.undoStack.push(entry);
+        return result;
+    }
+    markSaved() {
+        this.savedRevision = this.currentRevision;
+    }
+    clear() {
+        this.undoStack.length = 0;
+        this.redoStack.length = 0;
+        this.currentRevision = 0;
+        this.savedRevision = 0;
+    }
+}

package/dist/compiler/compileScenes.d.ts

@@ -0,0 +1,11 @@
+export interface CompileScenesOptions {
+    projectRoot: string | URL;
+    sourceRoots?: string[];
+    generatedDir?: string;
+}
+export declare class CompileSceneError extends Error {
+    readonly scene: string;
+    readonly source?: string | undefined;
+    constructor(message: string, scene: string, source?: string | undefined);
+}
+export declare function compileScenes(options: CompileScenesOptions): Promise<void>;