pixifact 0.1.3

package/dist/compiler/compileScenes.js

@@ -0,0 +1,220 @@
+import { access, mkdir, readdir, readFile, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { defaultSceneSourceRoots, generatedSceneModuleImport, generatedSceneModulePath, isIgnoredSceneSourceDirectory, normalizeSceneAssetId, pairedSceneScriptPath, resolveSceneReference, sceneClassAlias, sceneLocalName, toPosixPath, } from './sceneAssetPair.js';
+import { extractSceneScriptInterface } from './scriptInterfaceExtractor.js';
+import { findMissingScenePartReferences } from './scenePartValidation.js';
+import { parseSceneTemplate } from './templateParser.js';
+import { compileSceneTemplateToTs } from './typescriptCompiler.js';
+export class CompileSceneError extends Error {
+    scene;
+    source;
+    constructor(message, scene, source) {
+        super(message);
+        this.scene = scene;
+        this.source = source;
+        this.name = 'CompileSceneError';
+    }
+}
+export async function compileScenes(options) {
+    const projectRoot = typeof options.projectRoot === 'string'
+        ? options.projectRoot
+        : fileURLToPath(options.projectRoot);
+    const generatedDir = path.resolve(projectRoot, options.generatedDir ?? '.pixifact/generated');
+    const scenePaths = await collectSceneAssetIds(projectRoot, options.sourceRoots);
+    await mkdir(generatedDir, { recursive: true });
+    const templates = new Map();
+    for (const scenePath of scenePaths) {
+        const source = await readFile(path.resolve(projectRoot, scenePath), 'utf8');
+        try {
+            const template = parseSceneTemplate(source);
+            assertSceneLocalName(scenePath, template);
+            const descriptor = await readPairedSceneScript(projectRoot, scenePath, template);
+            template.interface = descriptor.interface;
+            templates.set(scenePath, normalizeSceneReferences(scenePath, template));
+        }
+        catch (error) {
+            throw new CompileSceneError(error instanceof Error ? error.message : String(error), scenePath, source);
+        }
+    }
+    const registryImports = [];
+    for (const scenePath of scenePaths) {
+        const template = templates.get(scenePath);
+        if (!template) {
+            throw new Error(`Missing parsed template for ${scenePath}.`);
+        }
+        const outputFile = generatedSceneModulePath(scenePath);
+        const generatedFile = path.join(generatedDir, outputFile);
+        const generatedFileDir = path.dirname(generatedFile);
+        const code = compileSceneTemplateToTs(template, {
+            registrationPath: scenePath,
+            scriptImport: {
+                exportName: template.name,
+                localName: sceneClassAlias(scenePath),
+                source: importSourceFor(path.resolve(projectRoot, pairedSceneScriptPath(scenePath)), generatedFileDir),
+            },
+            sceneImports: sceneImportsFor(template, templates, projectRoot, generatedFileDir),
+            sceneClassAliases: sceneClassAliasesFor(template),
+            sceneInterfaces: sceneInterfacesFor(template, templates),
+            textureImports: textureImportsFor(template, projectRoot, generatedFileDir),
+        });
+        await mkdir(path.dirname(generatedFile), { recursive: true });
+        await writeFile(generatedFile, code);
+        registryImports.push(`import ${JSON.stringify(generatedSceneModuleImport(scenePath))};`);
+    }
+    await writeFile(path.join(generatedDir, 'scenes.generated.ts'), `${registryImports.join('\n')}\n`);
+}
+async function collectSceneAssetIds(projectRoot, sourceRoots = defaultSceneSourceRoots) {
+    const scenes = [];
+    for (const sourceRoot of sourceRoots) {
+        const absoluteRoot = path.resolve(projectRoot, sourceRoot);
+        if (!await exists(absoluteRoot)) {
+            continue;
+        }
+        await collectScenesInDirectory(projectRoot, absoluteRoot, scenes);
+    }
+    return scenes.sort();
+}
+async function collectScenesInDirectory(projectRoot, directory, scenes) {
+    for (const entry of await readdir(directory, { withFileTypes: true })) {
+        if (entry.isDirectory()) {
+            if (!isIgnoredSceneSourceDirectory(entry.name)) {
+                await collectScenesInDirectory(projectRoot, path.join(directory, entry.name), scenes);
+            }
+            continue;
+        }
+        if (entry.isFile() && entry.name.endsWith('.scene')) {
+            scenes.push(normalizeSceneAssetId(toPosixPath(path.relative(projectRoot, path.join(directory, entry.name)))));
+        }
+    }
+}
+async function exists(filePath) {
+    try {
+        await access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function assertSceneLocalName(scenePath, template) {
+    const expected = sceneLocalName(scenePath);
+    if (template.name !== expected) {
+        throw new Error(`Scene "${scenePath}" name "${template.name}" must match file basename "${expected}".`);
+    }
+}
+async function readPairedSceneScript(projectRoot, scenePath, template) {
+    const scriptPath = pairedSceneScriptPath(scenePath);
+    const absoluteScriptPath = path.resolve(projectRoot, scriptPath);
+    if (!await exists(absoluteScriptPath)) {
+        throw new Error(`Scene "${scenePath}" requires paired script "${scriptPath}".`);
+    }
+    const descriptor = extractSceneScriptInterface(await readFile(absoluteScriptPath, 'utf8'), absoluteScriptPath, { scene: scenePath });
+    if (descriptor.className !== template.name) {
+        throw new Error(`Scene "${scenePath}" name "${template.name}" must match @scene class "${descriptor.className}".`);
+    }
+    const missingPart = findMissingScenePartReferences(template, descriptor.parts)[0];
+    if (missingPart) {
+        throw new Error(scenePartReferenceError(scenePath, missingPart.property, missingPart.id));
+    }
+    return descriptor;
+}
+function scenePartReferenceError(scenePath, property, id) {
+    return `Scene "${scenePath}" @part "${property}" references missing node id "${id}".`;
+}
+function normalizeSceneReferences(scenePath, template) {
+    const next = structuredClone(template);
+    function visit(node) {
+        if (node.kind === 'slotOutlet') {
+            return;
+        }
+        if (node.kind === 'pixi') {
+            node.children.forEach(visit);
+            return;
+        }
+        node.scene = resolveSceneReference(scenePath, node.scene);
+        for (const children of Object.values(node.slots)) {
+            children.forEach(visit);
+        }
+    }
+    next.children.forEach(visit);
+    return next;
+}
+function sceneImportsFor(template, templates, projectRoot, generatedFileDir) {
+    return [...collectSceneInstancePaths(template.children)]
+        .sort()
+        .map((scenePath) => {
+        const sceneTemplate = templates.get(scenePath);
+        if (!sceneTemplate) {
+            throw new Error(`Scene "${template.name}" references unknown Scene "${scenePath}".`);
+        }
+        return {
+            exportName: sceneTemplate.name,
+            localName: sceneClassAlias(scenePath),
+            source: importSourceFor(path.resolve(projectRoot, pairedSceneScriptPath(scenePath)), generatedFileDir),
+        };
+    });
+}
+function sceneClassAliasesFor(template) {
+    return Object.fromEntries([...collectSceneInstancePaths(template.children)].map((scenePath) => [scenePath, sceneClassAlias(scenePath)]));
+}
+function sceneInterfacesFor(template, templates) {
+    return Object.fromEntries([...collectSceneInstancePaths(template.children)].map((scenePath) => {
+        const sceneTemplate = templates.get(scenePath);
+        if (!sceneTemplate) {
+            throw new Error(`Scene "${template.name}" references unknown Scene "${scenePath}".`);
+        }
+        return [scenePath, sceneTemplate.interface];
+    }));
+}
+function importSourceFor(sourcePath, generatedFileDir) {
+    const source = path.relative(generatedFileDir, sourcePath).replaceAll(path.sep, '/').replace(/\.ts$/, '');
+    return source.startsWith('.') ? source : `./${source}`;
+}
+function textureImportsFor(template, projectRoot, generatedFileDir) {
+    const textures = new Set();
+    for (const child of template.children) {
+        collectTextureReferences(child, textures);
+    }
+    return Object.fromEntries([...textures].map((texture) => {
+        const normalized = texture.replace(/^\.\/+/, '').replace(/^\/+/, '');
+        const assetPath = path.resolve(projectRoot, normalized);
+        const source = path.relative(generatedFileDir, assetPath).replaceAll(path.sep, '/');
+        return [texture, `${source.startsWith('.') ? source : `./${source}`}?url`];
+    }));
+}
+function collectSceneInstancePaths(nodes, scenePaths = new Set()) {
+    for (const node of nodes) {
+        if (node.kind === 'slotOutlet') {
+            continue;
+        }
+        if (node.kind === 'pixi') {
+            collectSceneInstancePaths(node.children, scenePaths);
+            continue;
+        }
+        scenePaths.add(node.scene);
+        for (const children of Object.values(node.slots)) {
+            collectSceneInstancePaths(children, scenePaths);
+        }
+    }
+    return scenePaths;
+}
+function collectTextureReferences(node, textures) {
+    if (node.kind === 'slotOutlet') {
+        return;
+    }
+    if (node.kind === 'pixi') {
+        if (typeof node.props.texture === 'string') {
+            textures.add(node.props.texture);
+        }
+        for (const child of node.children) {
+            collectTextureReferences(child, textures);
+        }
+        return;
+    }
+    for (const children of Object.values(node.slots)) {
+        for (const child of children) {
+            collectTextureReferences(child, textures);
+        }
+    }
+}

package/dist/compiler/decorators.d.ts

@@ -0,0 +1,6 @@
+import type { SceneClassDecorator, SceneEventDecoratorOptions, SceneMemberDecorator, ScenePartDecoratorOptions, ScenePropDecoratorOptions, SceneSlotDecoratorOptions } from './spec.js';
+export declare function scene(): SceneClassDecorator;
+export declare function prop(options: ScenePropDecoratorOptions): SceneMemberDecorator;
+export declare function event(_options?: SceneEventDecoratorOptions): SceneMemberDecorator;
+export declare function slot(options?: SceneSlotDecoratorOptions): SceneMemberDecorator;
+export declare function part(options?: ScenePartDecoratorOptions): SceneMemberDecorator;

package/dist/compiler/decorators.js

@@ -0,0 +1,79 @@
+import { mountSceneClass } from './sceneRuntime.js';
+const metadataByConstructor = new WeakMap();
+export function scene() {
+    return ((constructor) => {
+        const SceneClass = class extends constructor {
+            constructor(...args) {
+                super(...args);
+                const result = mountSceneClass(this, SceneClass);
+                const metadata = sceneMetadata(constructor);
+                for (const [property, id] of metadata.parts) {
+                    Object.defineProperty(this, property, {
+                        configurable: true,
+                        enumerable: false,
+                        value: result.parts[id],
+                        writable: true,
+                    });
+                }
+                for (const [property, slotName] of metadata.slots) {
+                    Object.defineProperty(this, property, {
+                        configurable: true,
+                        enumerable: false,
+                        value: result.slots[slotName],
+                        writable: false,
+                    });
+                }
+                for (const [property, propOptions] of metadata.props) {
+                    if (propOptions.default !== undefined) {
+                        this[property] = propOptions.default;
+                    }
+                }
+                const ready = this.onMounted;
+                if (ready) {
+                    ready.call(this);
+                }
+            }
+        };
+        Object.defineProperty(SceneClass, 'name', { value: constructor.name });
+        return SceneClass;
+    });
+}
+export function prop(options) {
+    return ((target, propertyKey) => {
+        sceneMetadata(target.constructor).props.set(memberName(propertyKey), options);
+    });
+}
+export function event(_options = {}) {
+    return noopMemberDecorator;
+}
+export function slot(options = {}) {
+    return ((target, propertyKey) => {
+        const property = memberName(propertyKey);
+        sceneMetadata(target.constructor).slots.set(property, options.name ?? property);
+    });
+}
+export function part(options = {}) {
+    return ((target, propertyKey) => {
+        const property = memberName(propertyKey);
+        sceneMetadata(target.constructor).parts.set(property, options.id ?? property);
+    });
+}
+const noopMemberDecorator = (() => undefined);
+function sceneMetadata(constructor) {
+    let metadata = metadataByConstructor.get(constructor);
+    if (!metadata) {
+        metadata = {
+            parts: new Map(),
+            props: new Map(),
+            slots: new Map(),
+        };
+        metadataByConstructor.set(constructor, metadata);
+    }
+    return metadata;
+}
+function memberName(propertyKey) {
+    if (typeof propertyKey === 'symbol') {
+        throw new Error('Pixifact scene decorators require string member names.');
+    }
+    return propertyKey;
+}

package/dist/compiler/eventRuntime.d.ts

@@ -0,0 +1,8 @@
+export type SceneEventListener<TPayload = void> = TPayload extends void ? () => void : (payload: TPayload) => void;
+export interface SceneEvent<TPayload = void> {
+    connect(listener: SceneEventListener<TPayload>): () => void;
+    emit(...args: TPayload extends void ? [] : [TPayload]): void;
+}
+export type SceneActions = Record<string, (() => void) | undefined>;
+export declare function createEvent<TPayload = void>(): SceneEvent<TPayload>;
+export declare function connectSceneEvent(event: SceneEvent, actionName: string, owner: object, actions?: SceneActions): () => void;

package/dist/compiler/eventRuntime.js

@@ -0,0 +1,29 @@
+export function createEvent() {
+    const listeners = new Set();
+    return {
+        connect(listener) {
+            listeners.add(listener);
+            return () => {
+                listeners.delete(listener);
+            };
+        },
+        emit(...args) {
+            for (const listener of listeners) {
+                listener(...args);
+            }
+        },
+    };
+}
+export function connectSceneEvent(event, actionName, owner, actions = {}) {
+    const action = actions[actionName];
+    if (action) {
+        return event.connect(action);
+    }
+    const ownerAction = owner[actionName];
+    if (typeof ownerAction === 'function') {
+        return event.connect(() => {
+            ownerAction.call(owner);
+        });
+    }
+    throw new Error(`Scene action "${actionName}" was not found.`);
+}

package/dist/compiler/index.d.ts

@@ -0,0 +1,14 @@
+export * from './commands/index.js';
+export * from './decorators.js';
+export * from './eventRuntime.js';
+export * from './pixiNodeSchema.js';
+export * from './spec.js';
+export * from './scriptInterfaceExtractor.js';
+export * from './sceneRuntime.js';
+export * from './sceneAssetPair.js';
+export * from './scenePartValidation.js';
+export * from './sceneValidation.js';
+export * from './slotRuntime.js';
+export * from './templateParser.js';
+export * from './templateSerializer.js';
+export * from './typescriptCompiler.js';

package/dist/compiler/index.js

@@ -0,0 +1,14 @@
+export * from './commands/index.js';
+export * from './decorators.js';
+export * from './eventRuntime.js';
+export * from './pixiNodeSchema.js';
+export * from './spec.js';
+export * from './scriptInterfaceExtractor.js';
+export * from './sceneRuntime.js';
+export * from './sceneAssetPair.js';
+export * from './scenePartValidation.js';
+export * from './sceneValidation.js';
+export * from './slotRuntime.js';
+export * from './templateParser.js';
+export * from './templateSerializer.js';
+export * from './typescriptCompiler.js';

package/dist/compiler/pixiNodeSchema.d.ts

@@ -0,0 +1,39 @@
+import type { SceneTemplatePrimitiveType, SceneTemplateValue } from './spec.js';
+export type PixiSceneNodeType = Extract<SceneTemplatePrimitiveType, 'Container' | 'Sprite' | 'NineSliceSprite' | 'TilingSprite' | 'Text' | 'BitmapText' | 'HTMLText' | 'Graphics'>;
+export type PixiSceneFieldType = 'string' | 'number' | 'boolean' | 'color' | 'enum';
+export type PixiScenePropGroup = 'transform' | 'display' | 'sprite' | 'nineSlice' | 'tiling' | 'text' | 'graphics';
+export interface PixiSceneFieldSchema {
+    key: string;
+    type: PixiSceneFieldType;
+    options?: readonly (string | number)[];
+}
+export interface PixiSceneNodeSchema {
+    type: PixiSceneNodeType;
+    acceptsChildren: boolean;
+    defaults: Record<string, SceneTemplateValue>;
+    groups: Partial<Record<PixiScenePropGroup, readonly string[]>>;
+}
+export declare const pixiSceneTransformProps: readonly ["x", "y", "width", "height", "scaleX", "scaleY", "rotation", "pivotX", "pivotY", "skewX", "skewY"];
+export declare const pixiSceneDisplayProps: readonly ["alpha", "visible", "zIndex", "eventMode", "cursor", "label"];
+export declare const pixiSceneSpriteProps: readonly ["texture", "anchorX", "anchorY", "tint"];
+export declare const pixiSceneNineSliceProps: readonly ["leftWidth", "rightWidth", "topHeight", "bottomHeight"];
+export declare const pixiSceneTilingProps: readonly ["tilePositionX", "tilePositionY", "tileScaleX", "tileScaleY", "tileRotation"];
+export declare const pixiSceneTextProps: readonly ["text", "fontSize", "fontFamily", "fontWeight", "fill"];
+export declare const pixiSceneGraphicsProps: readonly ["shape", "radius", "fill", "fillAlpha", "strokeColor", "strokeWidth", "strokeAlpha"];
+export declare const pixiSceneTextStyleProps: readonly ["fontSize", "fontFamily", "fontWeight", "fill"];
+export declare const pixiSceneSpriteLikeProps: readonly ["texture", "anchorX", "anchorY", "tint", "leftWidth", "rightWidth", "topHeight", "bottomHeight", "tilePositionX", "tilePositionY", "tileScaleX", "tileScaleY", "tileRotation"];
+export declare const pixiSceneKnownProps: readonly ["x", "y", "width", "height", "scaleX", "scaleY", "rotation", "pivotX", "pivotY", "skewX", "skewY", "alpha", "visible", "zIndex", "eventMode", "cursor", "label", "texture", "anchorX", "anchorY", "tint", "leftWidth", "rightWidth", "topHeight", "bottomHeight", "tilePositionX", "tilePositionY", "tileScaleX", "tileScaleY", "tileRotation", "text", "fontSize", "fontFamily", "fontWeight", "fill", "shape", "radius", "fill", "fillAlpha", "strokeColor", "strokeWidth", "strokeAlpha"];
+export declare const pixiSceneAddableNodeTypes: readonly ["Container", "Sprite", "NineSliceSprite", "TilingSprite", "Text", "BitmapText", "HTMLText", "Graphics"];
+export declare const pixiSceneNodePropGroupOrder: readonly ["sprite", "nineSlice", "tiling", "text", "graphics"];
+export declare function pixiSceneNodeSchema(type: PixiSceneNodeType): PixiSceneNodeSchema;
+export declare function isPixiSceneNodeType(type: SceneTemplatePrimitiveType): type is PixiSceneNodeType;
+export declare function pixiSceneNodeDefaults(type: PixiSceneNodeType): {
+    [x: string]: SceneTemplateValue;
+};
+export declare function pixiSceneNodeAcceptsChildren(type: SceneTemplatePrimitiveType): boolean;
+export declare function pixiSceneNodePropKeys(type: PixiSceneNodeType): string[];
+export declare function pixiSceneNodePropGroups(type: PixiSceneNodeType): {
+    group: "text" | "sprite" | "nineSlice" | "tiling" | "graphics";
+    fields: readonly string[];
+}[];
+export declare function pixiSceneFieldSchema(key: string): PixiSceneFieldSchema | undefined;

package/dist/compiler/pixiNodeSchema.js

@@ -0,0 +1,267 @@
+export const pixiSceneTransformProps = [
+    'x',
+    'y',
+    'width',
+    'height',
+    'scaleX',
+    'scaleY',
+    'rotation',
+    'pivotX',
+    'pivotY',
+    'skewX',
+    'skewY',
+];
+export const pixiSceneDisplayProps = [
+    'alpha',
+    'visible',
+    'zIndex',
+    'eventMode',
+    'cursor',
+    'label',
+];
+export const pixiSceneSpriteProps = [
+    'texture',
+    'anchorX',
+    'anchorY',
+    'tint',
+];
+export const pixiSceneNineSliceProps = [
+    'leftWidth',
+    'rightWidth',
+    'topHeight',
+    'bottomHeight',
+];
+export const pixiSceneTilingProps = [
+    'tilePositionX',
+    'tilePositionY',
+    'tileScaleX',
+    'tileScaleY',
+    'tileRotation',
+];
+export const pixiSceneTextProps = [
+    'text',
+    'fontSize',
+    'fontFamily',
+    'fontWeight',
+    'fill',
+];
+export const pixiSceneGraphicsProps = [
+    'shape',
+    'radius',
+    'fill',
+    'fillAlpha',
+    'strokeColor',
+    'strokeWidth',
+    'strokeAlpha',
+];
+export const pixiSceneTextStyleProps = [
+    'fontSize',
+    'fontFamily',
+    'fontWeight',
+    'fill',
+];
+export const pixiSceneSpriteLikeProps = [
+    ...pixiSceneSpriteProps,
+    ...pixiSceneNineSliceProps,
+    ...pixiSceneTilingProps,
+];
+export const pixiSceneKnownProps = [
+    ...pixiSceneTransformProps,
+    ...pixiSceneDisplayProps,
+    ...pixiSceneSpriteLikeProps,
+    ...pixiSceneTextProps,
+    ...pixiSceneGraphicsProps,
+];
+export const pixiSceneAddableNodeTypes = [
+    'Container',
+    'Sprite',
+    'NineSliceSprite',
+    'TilingSprite',
+    'Text',
+    'BitmapText',
+    'HTMLText',
+    'Graphics',
+];
+export const pixiSceneNodePropGroupOrder = [
+    'sprite',
+    'nineSlice',
+    'tiling',
+    'text',
+    'graphics',
+];
+const pixiSceneFieldSchemas = {
+    x: { key: 'x', type: 'number' },
+    y: { key: 'y', type: 'number' },
+    width: { key: 'width', type: 'number' },
+    height: { key: 'height', type: 'number' },
+    scaleX: { key: 'scaleX', type: 'number' },
+    scaleY: { key: 'scaleY', type: 'number' },
+    rotation: { key: 'rotation', type: 'number' },
+    pivotX: { key: 'pivotX', type: 'number' },
+    pivotY: { key: 'pivotY', type: 'number' },
+    skewX: { key: 'skewX', type: 'number' },
+    skewY: { key: 'skewY', type: 'number' },
+    alpha: { key: 'alpha', type: 'number' },
+    visible: { key: 'visible', type: 'boolean' },
+    zIndex: { key: 'zIndex', type: 'number' },
+    eventMode: { key: 'eventMode', type: 'enum', options: ['none', 'passive', 'auto', 'static', 'dynamic'] },
+    cursor: { key: 'cursor', type: 'enum', options: ['default', 'pointer', 'text', 'grab', 'grabbing'] },
+    label: { key: 'label', type: 'string' },
+    texture: { key: 'texture', type: 'string' },
+    anchorX: { key: 'anchorX', type: 'number' },
+    anchorY: { key: 'anchorY', type: 'number' },
+    tint: { key: 'tint', type: 'color' },
+    leftWidth: { key: 'leftWidth', type: 'number' },
+    rightWidth: { key: 'rightWidth', type: 'number' },
+    topHeight: { key: 'topHeight', type: 'number' },
+    bottomHeight: { key: 'bottomHeight', type: 'number' },
+    tilePositionX: { key: 'tilePositionX', type: 'number' },
+    tilePositionY: { key: 'tilePositionY', type: 'number' },
+    tileScaleX: { key: 'tileScaleX', type: 'number' },
+    tileScaleY: { key: 'tileScaleY', type: 'number' },
+    tileRotation: { key: 'tileRotation', type: 'number' },
+    text: { key: 'text', type: 'string' },
+    fontSize: { key: 'fontSize', type: 'number' },
+    fontFamily: { key: 'fontFamily', type: 'string' },
+    fontWeight: { key: 'fontWeight', type: 'enum', options: [400, 500, 600, 700, '400', '500', '600', '700', 'bold'] },
+    fill: { key: 'fill', type: 'color' },
+    shape: { key: 'shape', type: 'enum', options: ['roundRect', 'rect'] },
+    radius: { key: 'radius', type: 'number' },
+    fillAlpha: { key: 'fillAlpha', type: 'number' },
+    strokeColor: { key: 'strokeColor', type: 'color' },
+    strokeWidth: { key: 'strokeWidth', type: 'number' },
+    strokeAlpha: { key: 'strokeAlpha', type: 'number' },
+};
+const pixiSceneNodeSchemas = {
+    Container: {
+        type: 'Container',
+        acceptsChildren: true,
+        defaults: {
+            width: 100,
+            height: 100,
+        },
+        groups: {},
+    },
+    Sprite: {
+        type: 'Sprite',
+        acceptsChildren: false,
+        defaults: {
+            width: 96,
+            height: 96,
+        },
+        groups: {
+            sprite: pixiSceneSpriteProps,
+        },
+    },
+    NineSliceSprite: {
+        type: 'NineSliceSprite',
+        acceptsChildren: false,
+        defaults: {
+            width: 160,
+            height: 80,
+            leftWidth: 10,
+            rightWidth: 10,
+            topHeight: 10,
+            bottomHeight: 10,
+        },
+        groups: {
+            sprite: pixiSceneSpriteProps,
+            nineSlice: pixiSceneNineSliceProps,
+        },
+    },
+    TilingSprite: {
+        type: 'TilingSprite',
+        acceptsChildren: false,
+        defaults: {
+            width: 160,
+            height: 96,
+            tileScaleX: 1,
+            tileScaleY: 1,
+        },
+        groups: {
+            sprite: pixiSceneSpriteProps,
+            tiling: pixiSceneTilingProps,
+        },
+    },
+    Text: {
+        type: 'Text',
+        acceptsChildren: false,
+        defaults: {
+            text: 'Text',
+            width: 120,
+            height: 28,
+            fontSize: 16,
+            fill: 0x111827,
+        },
+        groups: {
+            text: pixiSceneTextProps,
+        },
+    },
+    BitmapText: {
+        type: 'BitmapText',
+        acceptsChildren: false,
+        defaults: {
+            text: 'Text',
+            width: 120,
+            height: 28,
+            fontSize: 16,
+            fill: 0x111827,
+        },
+        groups: {
+            text: pixiSceneTextProps,
+        },
+    },
+    HTMLText: {
+        type: 'HTMLText',
+        acceptsChildren: false,
+        defaults: {
+            text: 'Text',
+            width: 120,
+            height: 28,
+            fontSize: 16,
+            fill: 0x111827,
+        },
+        groups: {
+            text: pixiSceneTextProps,
+        },
+    },
+    Graphics: {
+        type: 'Graphics',
+        acceptsChildren: false,
+        defaults: {
+            shape: 'roundRect',
+            width: 100,
+            height: 60,
+            radius: 8,
+            fill: 0xe5e7eb,
+        },
+        groups: {
+            graphics: pixiSceneGraphicsProps,
+        },
+    },
+};
+export function pixiSceneNodeSchema(type) {
+    return pixiSceneNodeSchemas[type];
+}
+export function isPixiSceneNodeType(type) {
+    return pixiSceneAddableNodeTypes.includes(type);
+}
+export function pixiSceneNodeDefaults(type) {
+    return { ...pixiSceneNodeSchemas[type].defaults };
+}
+export function pixiSceneNodeAcceptsChildren(type) {
+    return isPixiSceneNodeType(type) && pixiSceneNodeSchemas[type].acceptsChildren;
+}
+export function pixiSceneNodePropKeys(type) {
+    return Object.values(pixiSceneNodeSchemas[type].groups).flat();
+}
+export function pixiSceneNodePropGroups(type) {
+    const groups = pixiSceneNodeSchemas[type].groups;
+    return pixiSceneNodePropGroupOrder.flatMap((group) => {
+        const fields = groups[group];
+        return fields ? [{ group, fields }] : [];
+    });
+}
+export function pixiSceneFieldSchema(key) {
+    return pixiSceneFieldSchemas[key];
+}