pixifact 0.1.3 → 0.1.5

package/dist/authoring/DesignToken.js

@@ -1,33 +0,0 @@
-function hasNumberValue(record, value) {
-    return typeof value === 'number' && !!record && Object.values(record).includes(value);
-}
-export function validateDesignTokenValue(tokens, target, prop, value) {
-    if (!tokens) {
-        return undefined;
-    }
-    if ((prop === 'color' || prop.toLowerCase().includes('color')) && !hasNumberValue(tokens.colors, value)) {
-        return {
-            target,
-            value,
-            message: `${target} uses color ${String(value)} outside design tokens.`,
-        };
-    }
-    if ((prop === 'radius' || prop.toLowerCase().includes('radius')) && !hasNumberValue(tokens.radius, value)) {
-        return {
-            target,
-            value,
-            message: `${target} uses radius ${String(value)} outside design tokens.`,
-        };
-    }
-    if ((prop === 'x' || prop === 'y' || prop === 'width' || prop === 'height') && typeof value === 'number' && tokens.spacing) {
-        const spacingValues = Object.values(tokens.spacing);
-        if (spacingValues.length > 0 && !spacingValues.some((spacing) => value % spacing === 0)) {
-            return {
-                target,
-                value,
-                message: `${target} uses ${prop}=${value}, which does not align to spacing tokens.`,
-            };
-        }
-    }
-    return undefined;
-}

package/dist/authoring/DiffModel.d.ts

@@ -1,10 +0,0 @@
-import type { SceneCommand } from "../commands/index.js";
-import type { SceneSpec } from "../scene/index.js";
-export interface DiffEntry {
-    target: string;
-    before: unknown;
-    after: unknown;
-    command: SceneCommand;
-}
-export declare function diffCommand(scene: SceneSpec, command: SceneCommand): DiffEntry[];
-export declare function diffCommands(scene: SceneSpec, commands: SceneCommand[]): DiffEntry[];

package/dist/authoring/DiffModel.js

@@ -1,104 +0,0 @@
-import { findComponent, findNode } from "../commands/utils.js";
-function formatTarget(parts) {
-    return parts.filter(Boolean).join('.');
-}
-export function diffCommand(scene, command) {
-    switch (command.op) {
-        case 'setNodeProp': {
-            const node = findNode(scene, command.node)?.node;
-            return [{
-                    target: formatTarget([command.node, command.prop]),
-                    before: node?.[command.prop],
-                    after: command.value,
-                    command,
-                }];
-        }
-        case 'setTransform': {
-            const node = findNode(scene, command.node)?.node;
-            return Object.entries(command.values).map(([key, value]) => ({
-                target: formatTarget([command.node, 'transform', key]),
-                before: node?.transform?.[key],
-                after: value,
-                command,
-            }));
-        }
-        case 'setNodeData': {
-            const node = findNode(scene, command.node)?.node;
-            const data = node && node.kind === command.field
-                ? node[command.field]
-                : undefined;
-            return [{
-                    target: formatTarget([command.node, command.field, command.prop]),
-                    before: data?.[command.prop],
-                    after: command.value,
-                    command,
-                }];
-        }
-        case 'setComponentProp': {
-            const node = findNode(scene, command.node)?.node;
-            const component = node ? findComponent(node, command.component)?.component : undefined;
-            return [{
-                    target: formatTarget([command.node, command.component, command.prop]),
-                    before: component?.props?.[command.prop],
-                    after: command.value,
-                    command,
-                }];
-        }
-        case 'addComponent':
-            return [{
-                    target: formatTarget([command.node, command.component.id ?? command.component.type]),
-                    before: undefined,
-                    after: command.component,
-                    command,
-                }];
-        case 'removeComponent': {
-            const node = findNode(scene, command.node)?.node;
-            const component = node ? findComponent(node, command.component)?.component : undefined;
-            return [{
-                    target: formatTarget([command.node, command.component]),
-                    before: component,
-                    after: undefined,
-                    command,
-                }];
-        }
-        case 'createNode':
-            return [{
-                    target: formatTarget([command.parent ?? 'root', command.node.id ?? command.node.key ?? command.node.name]),
-                    before: undefined,
-                    after: command.node,
-                    command,
-                }];
-        case 'deleteNode': {
-            const node = findNode(scene, command.node)?.node;
-            return [{
-                    target: command.node,
-                    before: node,
-                    after: undefined,
-                    command,
-                }];
-        }
-        case 'reparentNode': {
-            const node = findNode(scene, command.node);
-            return [{
-                    target: formatTarget([command.node, 'parent']),
-                    before: node?.parent?.key ?? node?.parent?.id ?? node?.parent?.name,
-                    after: command.parent ?? 'root',
-                    command,
-                }];
-        }
-        case 'reorderNode': {
-            const node = findNode(scene, command.node);
-            return [{
-                    target: formatTarget([command.node, 'index']),
-                    before: node?.index,
-                    after: command.index,
-                    command,
-                }];
-        }
-        case 'batch':
-            return diffCommands(scene, command.commands);
-    }
-}
-export function diffCommands(scene, commands) {
-    return commands.flatMap((command) => diffCommand(scene, command));
-}

package/dist/authoring/InspectorModel.d.ts

@@ -1,27 +0,0 @@
-import type { ComponentSchema, PropSchema } from "../runtime/index.js";
-import type { NodeSpec, SceneSpec } from "../scene/index.js";
-export interface InspectorFieldModel {
-    key: string;
-    label: string;
-    type: string;
-    value: unknown;
-    schema?: PropSchema;
-}
-export interface InspectorComponentModel {
-    id?: string;
-    type: string;
-    displayName: string;
-    schema?: ComponentSchema;
-    fields: InspectorFieldModel[];
-}
-export interface InspectorNodeModel {
-    id?: string;
-    key?: string;
-    role?: string;
-    name?: string;
-    kind: NodeSpec['kind'];
-    transform: InspectorFieldModel[];
-    display: InspectorComponentModel[];
-    components: InspectorComponentModel[];
-}
-export declare function buildInspectorModel(scene: SceneSpec, nodeLocator: string): InspectorNodeModel | undefined;

package/dist/authoring/InspectorModel.js

@@ -1,139 +0,0 @@
-import { ComponentRegistry } from "../runtime/index.js";
-import { findNode } from "../commands/utils.js";
-const transformFields = [
-    'x',
-    'y',
-    'width',
-    'height',
-    'anchorX',
-    'anchorY',
-    'scaleX',
-    'scaleY',
-    'rotation',
-];
-function buildTransformFields(node) {
-    const transform = node.transform ?? {};
-    return transformFields.map((key) => ({
-        key,
-        label: key,
-        type: 'number',
-        value: transform[key],
-    }));
-}
-function field(key, type, value, schema) {
-    return {
-        key,
-        label: key,
-        type,
-        value,
-        schema,
-    };
-}
-function enumSchema(key, options) {
-    return {
-        key,
-        type: 'enum',
-        options,
-    };
-}
-function buildDisplayModel(node) {
-    switch (node.kind) {
-        case 'image':
-            return [{
-                    type: 'node.image',
-                    displayName: 'Image',
-                    fields: [
-                        field('mode', 'enum', node.image?.mode, enumSchema('mode', ['sprite', 'nineSlice'])),
-                        field('src', 'string', node.image?.src),
-                        field('tint', 'color', node.image?.tint),
-                        field('leftWidth', 'number', node.image?.leftWidth),
-                        field('rightWidth', 'number', node.image?.rightWidth),
-                        field('topHeight', 'number', node.image?.topHeight),
-                        field('bottomHeight', 'number', node.image?.bottomHeight),
-                    ],
-                }];
-        case 'text':
-            return [{
-                    type: 'node.text',
-                    displayName: 'Text',
-                    fields: [
-                        field('value', 'string', node.text?.value),
-                        field('color', 'color', node.text?.color),
-                        field('fontSize', 'number', node.text?.fontSize),
-                        field('fontFamily', 'string', Array.isArray(node.text?.fontFamily) ? node.text.fontFamily.join(',') : node.text?.fontFamily),
-                        field('fontWeight', 'enum', node.text?.fontWeight, enumSchema('fontWeight', ['normal', 'bold', 'bolder', 'lighter', '100', '200', '300', '400', '500', '600', '700', '800', '900'])),
-                        field('center', 'boolean', node.text?.center),
-                    ],
-                }];
-        case 'input':
-            return [{
-                    type: 'node.input',
-                    displayName: 'Input',
-                    fields: [
-                        field('value', 'string', node.input?.value),
-                        field('backgroundColor', 'color', node.input?.backgroundColor),
-                        field('borderColor', 'color', node.input?.borderColor),
-                        field('borderSize', 'number', node.input?.borderSize),
-                        field('textColor', 'string', node.input?.textColor),
-                        field('fontSize', 'number', node.input?.fontSize),
-                        field('fontFamily', 'string', Array.isArray(node.input?.fontFamily) ? node.input.fontFamily.join(',') : node.input?.fontFamily),
-                        field('paddingLeft', 'number', node.input?.paddingLeft),
-                        field('paddingRight', 'number', node.input?.paddingRight),
-                        field('paddingTop', 'number', node.input?.paddingTop),
-                        field('paddingBottom', 'number', node.input?.paddingBottom),
-                    ],
-                }];
-        case 'shape':
-            return [{
-                    type: 'node.shape',
-                    displayName: 'Shape',
-                    fields: [
-                        field('type', 'enum', node.shape?.type, enumSchema('type', ['rect', 'roundedRect'])),
-                        field('color', 'color', node.shape?.color),
-                        field('fillAlpha', 'number', node.shape?.fillAlpha),
-                        field('radius', 'number', node.shape?.radius),
-                        field('strokeColor', 'color', node.shape?.strokeColor),
-                        field('strokeWidth', 'number', node.shape?.strokeWidth),
-                        field('strokeAlpha', 'number', node.shape?.strokeAlpha),
-                    ],
-                }];
-        case 'container':
-            return [];
-    }
-}
-function buildComponentFields(component, schema) {
-    return (schema?.props ?? []).filter((prop) => !prop.hidden).map((prop) => ({
-        key: prop.key,
-        label: prop.key,
-        type: prop.type,
-        value: component.props?.[prop.key] ?? prop.default,
-        schema: prop,
-    }));
-}
-function buildComponentModel(component) {
-    const schema = ComponentRegistry.get(component.type);
-    return {
-        id: component.id,
-        type: component.type,
-        displayName: schema?.displayName ?? component.type,
-        schema,
-        fields: buildComponentFields(component, schema),
-    };
-}
-export function buildInspectorModel(scene, nodeLocator) {
-    const located = findNode(scene, nodeLocator);
-    if (!located) {
-        return undefined;
-    }
-    const node = located.node;
-    return {
-        id: node.id,
-        key: node.key,
-        role: node.role,
-        name: node.name,
-        kind: node.kind,
-        transform: buildTransformFields(node),
-        display: buildDisplayModel(node),
-        components: (node.components ?? []).map(buildComponentModel),
-    };
-}

package/dist/authoring/LogicGraph.d.ts

@@ -1,66 +0,0 @@
-import type { SceneSpec } from "../scene/index.js";
-import type { ActionSpec } from "./ActionRegistry.js";
-export type LogicValue = {
-    kind: 'const';
-    value: unknown;
-} | {
-    kind: 'state';
-    path: string;
-} | {
-    kind: 'payload';
-    path: string;
-};
-export type LogicConditionOperator = 'eq' | 'neq' | 'lt' | 'lte' | 'gt' | 'gte' | 'truthy' | 'falsy';
-export interface LogicConditionSpec {
-    left: LogicValue;
-    op: LogicConditionOperator;
-    right?: LogicValue;
-}
-export type LogicStepSpec = {
-    id: string;
-    type: 'condition';
-    condition: LogicConditionSpec;
-} | {
-    id: string;
-    type: 'setState';
-    path: string;
-    value: LogicValue;
-} | {
-    id: string;
-    type: 'setNodeVisible';
-    node: string;
-    visible: boolean;
-} | {
-    id: string;
-    type: 'emitAction';
-    action: string;
-} | {
-    id: string;
-    type: 'comment';
-    text: string;
-};
-export interface LogicFlowSpec {
-    id: string;
-    action: string;
-    name?: string;
-    description?: string;
-    steps: LogicStepSpec[];
-}
-export interface LogicGraphSpec {
-    version: 1;
-    type: 'pixifact.logicGraph';
-    flows: LogicFlowSpec[];
-}
-export interface LogicValidationContext {
-    actions?: readonly ActionSpec[];
-    scene?: SceneSpec;
-}
-export interface LogicValidationResult {
-    ok: boolean;
-    errors: string[];
-}
-export declare function createLogicGraph(flows?: LogicFlowSpec[]): LogicGraphSpec;
-export declare function createUseInventoryItemFlow(): LogicFlowSpec;
-export declare function validateLogicGraph(graph: LogicGraphSpec, context?: LogicValidationContext): LogicValidationResult;
-export declare function compileLogicGraphToTypescript(graph: LogicGraphSpec): string;
-export declare function summarizeLogicGraphForAi(graph: LogicGraphSpec | undefined): string;

package/dist/authoring/LogicGraph.js

@@ -1,184 +0,0 @@
-import { findNode } from "../commands/utils.js";
-import { actionExists } from "./ActionRegistry.js";
-export function createLogicGraph(flows = []) {
-    return {
-        version: 1,
-        type: 'pixifact.logicGraph',
-        flows,
-    };
-}
-export function createUseInventoryItemFlow() {
-    return {
-        id: 'flow-useInventoryItem',
-        action: 'useInventoryItem',
-        name: 'Use Inventory Item',
-        description: 'Decrease item quantity and remove empty inventory slots.',
-        steps: [
-            {
-                id: 'hasQuantity',
-                type: 'condition',
-                condition: {
-                    left: { kind: 'state', path: 'selectedItem.quantity' },
-                    op: 'gt',
-                    right: { kind: 'const', value: 0 },
-                },
-            },
-            {
-                id: 'decreaseQuantity',
-                type: 'setState',
-                path: 'selectedItem.quantity',
-                value: { kind: 'state', path: 'selectedItem.quantity - 1' },
-            },
-            {
-                id: 'removeEmptySlot',
-                type: 'comment',
-                text: 'When quantity reaches zero, remove or hide the inventory slot in game code.',
-            },
-        ],
-    };
-}
-function validateValue(value, errors, target) {
-    if (value.kind !== 'const' && !value.path) {
-        errors.push(`${target} requires a path.`);
-    }
-}
-function validateStep(step, flow, context, errors) {
-    if (!step.id) {
-        errors.push(`Logic flow "${flow.id}" contains a step without id.`);
-    }
-    switch (step.type) {
-        case 'condition':
-            validateValue(step.condition.left, errors, `${step.id}.condition.left`);
-            if (step.condition.op !== 'truthy' && step.condition.op !== 'falsy' && !step.condition.right) {
-                errors.push(`${step.id}.condition.right is required for ${step.condition.op}.`);
-            }
-            if (step.condition.right) {
-                validateValue(step.condition.right, errors, `${step.id}.condition.right`);
-            }
-            break;
-        case 'setState':
-            if (!step.path) {
-                errors.push(`${step.id}.path is required.`);
-            }
-            validateValue(step.value, errors, `${step.id}.value`);
-            break;
-        case 'setNodeVisible':
-            if (context.scene && !findNode(context.scene, step.node)) {
-                errors.push(`${step.id} references missing node "${step.node}".`);
-            }
-            break;
-        case 'emitAction':
-            if (context.actions && !actionExists(context.actions, step.action)) {
-                errors.push(`${step.id} emits undeclared action "${step.action}".`);
-            }
-            break;
-        case 'comment':
-            if (!step.text) {
-                errors.push(`${step.id}.text is required.`);
-            }
-            break;
-    }
-}
-export function validateLogicGraph(graph, context = {}) {
-    const errors = [];
-    if (graph.type !== 'pixifact.logicGraph') {
-        errors.push('Logic graph type must be "pixifact.logicGraph".');
-    }
-    const flowIds = new Set();
-    for (const flow of graph.flows) {
-        if (!flow.id) {
-            errors.push('Logic flow id is required.');
-        }
-        if (flowIds.has(flow.id)) {
-            errors.push(`Duplicate logic flow id "${flow.id}".`);
-        }
-        flowIds.add(flow.id);
-        if (context.actions && !actionExists(context.actions, flow.action)) {
-            errors.push(`Logic flow "${flow.id}" references undeclared action "${flow.action}".`);
-        }
-        for (const step of flow.steps) {
-            validateStep(step, flow, context, errors);
-        }
-    }
-    return {
-        ok: errors.length === 0,
-        errors,
-    };
-}
-function accessPath(root, path) {
-    if (path.includes(' - ') || path.includes(' + ')) {
-        const [left, operator, right] = path.split(/\s+/);
-        const numeric = Number(right);
-        if ((operator === '-' || operator === '+') && Number.isFinite(numeric)) {
-            return `(${accessPath(root, left)} ${operator} ${JSON.stringify(numeric)})`;
-        }
-    }
-    return `${root}${path.split('.').map((part) => `[${JSON.stringify(part)}]`).join('')}`;
-}
-function compileValue(value) {
-    switch (value.kind) {
-        case 'const':
-            return JSON.stringify(value.value);
-        case 'state':
-            return accessPath('context.state', value.path);
-        case 'payload':
-            return accessPath('payload', value.path);
-    }
-}
-function compileCondition(condition) {
-    const left = compileValue(condition.left);
-    const right = condition.right ? compileValue(condition.right) : undefined;
-    switch (condition.op) {
-        case 'truthy':
-            return `Boolean(${left})`;
-        case 'falsy':
-            return `!Boolean(${left})`;
-        case 'eq':
-            return `${left} === ${right}`;
-        case 'neq':
-            return `${left} !== ${right}`;
-        case 'lt':
-            return `${left} < ${right}`;
-        case 'lte':
-            return `${left} <= ${right}`;
-        case 'gt':
-            return `${left} > ${right}`;
-        case 'gte':
-            return `${left} >= ${right}`;
-    }
-}
-function compileStep(step) {
-    switch (step.type) {
-        case 'condition':
-            return `        if (!(${compileCondition(step.condition)})) return;`;
-        case 'setState':
-            return `        ${accessPath('context.state', step.path)} = ${compileValue(step.value)};`;
-        case 'setNodeVisible':
-            return `        context.setNodeVisible?.(${JSON.stringify(step.node)}, ${JSON.stringify(step.visible)});`;
-        case 'emitAction':
-            return `        context.emit?.(${JSON.stringify(step.action)});`;
-        case 'comment':
-            return `        // ${step.text.replaceAll('\n', ' ')}`;
-    }
-}
-export function compileLogicGraphToTypescript(graph) {
-    const handlers = graph.flows.map((flow) => {
-        const steps = flow.steps.map(compileStep).join('\n');
-        return `    ${JSON.stringify(flow.action)}(context: LogicRuntimeContext, payload: Record<string, unknown> = {}) {\n${steps}\n    },`;
-    }).join('\n');
-    return `export interface LogicRuntimeContext {
-    state: Record<string, unknown>;
-    emit?: (action: string, payload?: unknown) => void;
-    setNodeVisible?: (node: string, visible: boolean) => void;
-}
-
-export const logicHandlers = {
-${handlers}
-};
-`;
-}
-export function summarizeLogicGraphForAi(graph) {
-    return (graph?.flows ?? [])
-        .map((flow) => `- ${flow.action}: ${flow.steps.map((step) => step.type).join(' -> ')}`)
-        .join('\n');
-}

package/dist/authoring/OverrideJournal.d.ts

@@ -1,18 +0,0 @@
-export interface LockSpec {
-    target: 'transform' | 'component' | 'nodeData';
-    node: string;
-    field?: string;
-    component?: string;
-    prop: string;
-    reason?: string;
-}
-export interface OverrideSpec {
-    source: 'manual' | 'agent';
-    target: string;
-    before: unknown;
-    after: unknown;
-    reason?: string;
-    timestamp: number;
-}
-export declare function lockKey(lock: Omit<LockSpec, 'reason'>): string;
-export declare function isLocked(locks: readonly LockSpec[] | undefined, candidate: Omit<LockSpec, 'reason'>): boolean;

package/dist/authoring/OverrideJournal.js

@@ -1,23 +0,0 @@
-export function lockKey(lock) {
-    if (lock.target === 'transform') {
-        return `${lock.node}.transform.${lock.prop}`;
-    }
-    if (lock.target === 'nodeData') {
-        return `${lock.node}.${lock.field}.${lock.prop}`;
-    }
-    return `${lock.node}.${lock.component}.${lock.prop}`;
-}
-export function isLocked(locks, candidate) {
-    return (locks ?? []).some((lock) => {
-        if (lock.target !== candidate.target || lock.node !== candidate.node || lock.prop !== candidate.prop) {
-            return false;
-        }
-        if (candidate.target === 'component') {
-            return lock.component === candidate.component;
-        }
-        if (candidate.target === 'nodeData') {
-            return lock.field === candidate.field;
-        }
-        return true;
-    });
-}

package/dist/authoring/PreferenceMemory.d.ts

@@ -1,21 +0,0 @@
-import type { OverrideSpec } from "./OverrideJournal.js";
-export interface PreferenceMemory {
-    id: string;
-    context: string;
-    pattern: string;
-    before?: unknown;
-    after: unknown;
-    reason?: string;
-    confidence: number;
-    enabled?: boolean;
-    source?: 'manual' | 'imported' | 'agent';
-}
-export interface MemorySuggestion {
-    id: string;
-    memory: PreferenceMemory;
-    sourceOverride: OverrideSpec;
-}
-export declare function createMemorySuggestion(override: OverrideSpec): MemorySuggestion | undefined;
-export declare function createMemorySuggestions(overrides: readonly OverrideSpec[]): MemorySuggestion[];
-export declare function summarizeMemoryForAgent(memory: readonly PreferenceMemory[]): string;
-export declare function enabledMemory(memory: readonly PreferenceMemory[]): PreferenceMemory[];

package/dist/authoring/PreferenceMemory.js

@@ -1,39 +0,0 @@
-function propFromTarget(target) {
-    const parts = target.split('.');
-    return parts.at(-1) ?? target;
-}
-export function createMemorySuggestion(override) {
-    if (override.source !== 'manual') {
-        return undefined;
-    }
-    const prop = propFromTarget(override.target);
-    return {
-        id: `suggestion-${override.timestamp}-${override.target}`,
-        sourceOverride: override,
-        memory: {
-            id: `memory-${override.timestamp}-${override.target}`,
-            context: override.target,
-            pattern: `When editing ${override.target}, prefer ${prop}=${JSON.stringify(override.after)}.`,
-            before: override.before,
-            after: override.after,
-            reason: override.reason,
-            confidence: 0.5,
-            enabled: true,
-            source: 'manual',
-        },
-    };
-}
-export function createMemorySuggestions(overrides) {
-    return overrides
-        .map(createMemorySuggestion)
-        .filter((suggestion) => !!suggestion);
-}
-export function summarizeMemoryForAgent(memory) {
-    return memory
-        .filter((item) => item.enabled !== false)
-        .map((item) => `- ${item.pattern}`)
-        .join('\n');
-}
-export function enabledMemory(memory) {
-    return memory.filter((item) => item.enabled !== false);
-}

package/dist/authoring/RuntimePreview.d.ts

@@ -1,11 +0,0 @@
-import { Group } from "../runtime/index.js";
-import type { Component } from "../runtime/index.js";
-import type { InstantiateContext, SceneSpec } from "../scene/index.js";
-export interface RuntimePreview {
-    root: Group;
-    nodes: Map<string, Group>;
-    components: Map<string, Component>;
-    resolveNode(runtimeNode: Group): string | undefined;
-}
-export declare function createRuntimePreview(scene: SceneSpec, parent?: Group, context?: InstantiateContext): RuntimePreview;
-export declare function destroyRuntimePreview(preview?: RuntimePreview): void;