pixifact 0.3.0 → 0.5.0

package/dist/platform/wechat/types.d.ts

@@ -0,0 +1,105 @@
+export interface WechatCanvas {
+    width: number;
+    height: number;
+    isConnected?: boolean;
+    style?: Record<string, string>;
+    getContext(contextId: string, options?: Record<string, unknown>): unknown;
+    getBoundingClientRect?(): {
+        bottom: number;
+        height: number;
+        left: number;
+        right: number;
+        top: number;
+        width: number;
+        x: number;
+        y: number;
+    };
+    requestAnimationFrame?(callback: FrameRequestCallback): number;
+    cancelAnimationFrame?(requestId: number): void;
+    addEventListener?(type: string, listener: EventListenerOrEventListenerObject, options?: unknown): void;
+    removeEventListener?(type: string, listener: EventListenerOrEventListenerObject, options?: unknown): void;
+    dispatchEvent?(event: Event): boolean;
+}
+export interface WechatImage {
+    width: number;
+    height: number;
+    complete?: boolean;
+    crossOrigin?: string | null;
+    src: string;
+    onload: (() => void) | null;
+    onerror: ((error: unknown) => void) | null;
+}
+export interface WechatTouch {
+    clientX?: number;
+    clientY?: number;
+    force?: number;
+    identifier?: number;
+    pageX?: number;
+    pageY?: number;
+    x?: number;
+    y?: number;
+}
+export interface WechatTouchEvent {
+    changedTouches?: WechatTouch[];
+    touches?: WechatTouch[];
+}
+export interface WechatMiniGameApi {
+    createCanvas(): WechatCanvas;
+    createImage(): WechatImage;
+    createOffscreenCanvas?(options: {
+        type: '2d' | 'webgl';
+        width: number;
+        height: number;
+    }): WechatCanvas;
+    getDeviceInfo?(): Record<string, unknown>;
+    getFileSystemManager(): {
+        readFile(options: {
+            filePath: string;
+            fail(error: {
+                errMsg: string;
+            }): void;
+            success(result: {
+                data: ArrayBuffer | string;
+            }): void;
+        }): void;
+    };
+    getSystemInfoSync?(): Record<string, unknown>;
+    getWindowInfo?(): Record<string, unknown>;
+    loadSubpackage(options: {
+        name: string;
+        fail(error: {
+            errMsg: string;
+        }): void;
+        success(): void;
+    }): {
+        onProgressUpdate(callback: (progress: {
+            progress: number;
+        }) => void): void;
+    };
+    request(options: {
+        url: string;
+        method: 'GET';
+        responseType: 'arraybuffer';
+        fail(error: {
+            errMsg: string;
+        }): void;
+        success(result: {
+            data: ArrayBuffer | string | Record<string, unknown>;
+            header: Record<string, string>;
+            statusCode: number;
+        }): void;
+    }): void;
+    onHide(callback: () => void): void;
+    offHide?(callback: () => void): void;
+    onShow(callback: () => void): void;
+    offShow?(callback: () => void): void;
+    onTouchStart(callback: (event: WechatTouchEvent) => void): void;
+    offTouchStart?(callback: (event: WechatTouchEvent) => void): void;
+    onTouchMove(callback: (event: WechatTouchEvent) => void): void;
+    offTouchMove?(callback: (event: WechatTouchEvent) => void): void;
+    onTouchEnd(callback: (event: WechatTouchEvent) => void): void;
+    offTouchEnd?(callback: (event: WechatTouchEvent) => void): void;
+    onTouchCancel(callback: (event: WechatTouchEvent) => void): void;
+    offTouchCancel?(callback: (event: WechatTouchEvent) => void): void;
+}
+export declare function wechatApi(): WechatMiniGameApi;

package/dist/platform/wechat/types.js

@@ -0,0 +1,3 @@
+export function wechatApi() {
+    return globalThis.wx;
+}

package/dist/project/index.d.ts

@@ -10,12 +10,33 @@ export interface PixifactProjectResolution {
     width: number;
     height: number;
 }
+export interface PixifactProjectResourcePack {
+    root: string;
+}
+export type PixifactWechatResourcePack = {
+    delivery: 'subpackage';
+    root: string;
+} | {
+    delivery: 'remote';
+    baseUrl: string;
+};
+export interface PixifactWechatTargetConfig {
+    entry: string;
+    configDir: string;
+    outDir: string;
+    resourcePacks: Record<string, PixifactWechatResourcePack>;
+}
+export interface PixifactProjectTargets {
+    wechat?: PixifactWechatTargetConfig;
+}
 export interface PixifactProjectConfig {
     version: 1;
     name: string;
     resolution: PixifactProjectResolution;
     viewport: PixifactProjectViewport;
     scenes: Record<string, string>;
+    resourcePacks?: Record<string, PixifactProjectResourcePack>;
+    targets?: PixifactProjectTargets;
     run?: PixifactProjectRunConfig;
 }
 export type PixifactProjectViewport = PixifactViewportConfig;
@@ -24,6 +45,8 @@ export interface PixifactProjectSummary {
     resolution: PixifactProjectResolution;
     viewport: PixifactProjectViewport;
     scenes: Record<string, string>;
+    resourcePacks?: Record<string, PixifactProjectResourcePack>;
+    targets?: PixifactProjectTargets;
     run?: PixifactProjectRunConfig;
 }
 export declare const defaultPixifactProjectResolution: PixifactProjectResolution;

package/dist/project/index.js

@@ -49,6 +49,13 @@ function normalizeRunCwd(value) {
     }
     return normalizeProjectPath(input, 'run.cwd');
 }
+function normalizeProjectChildPath(value, name) {
+    const input = normalizeProjectPath(value, name);
+    if (input === '.') {
+        throw new Error(`${name} must not be projectRoot.`);
+    }
+    return input;
+}
 function parseScenes(value) {
     const scenes = assertRecord(value, 'scenes');
     return Object.fromEntries(Object.entries(scenes).map(([key, scenePath]) => [
@@ -97,17 +104,77 @@ function parseRun(value) {
         ...(run.url === undefined ? {} : { url: assertString(run.url, 'run.url') }),
     };
 }
+function parseResourcePacks(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    const packs = assertRecord(value, 'resourcePacks');
+    return Object.fromEntries(Object.entries(packs).map(([name, packValue]) => {
+        const pack = assertRecord(packValue, `resourcePacks.${name}`);
+        return [assertString(name, 'resource pack name'), {
+                root: normalizeProjectChildPath(pack.root, `resourcePacks.${name}.root`),
+            }];
+    }));
+}
+function parseWechatResourcePacks(value) {
+    const packs = assertRecord(value, 'targets.wechat.resourcePacks');
+    return Object.fromEntries(Object.entries(packs).map(([name, packValue]) => {
+        const pack = assertRecord(packValue, `targets.wechat.resourcePacks.${name}`);
+        const delivery = assertString(pack.delivery, `targets.wechat.resourcePacks.${name}.delivery`);
+        if (delivery === 'subpackage') {
+            return [name, {
+                    delivery,
+                    root: normalizeProjectChildPath(pack.root, `targets.wechat.resourcePacks.${name}.root`),
+                }];
+        }
+        if (delivery === 'remote') {
+            return [name, {
+                    delivery,
+                    baseUrl: assertString(pack.baseUrl, `targets.wechat.resourcePacks.${name}.baseUrl`).replace(/\/+$/, ''),
+                }];
+        }
+        throw new Error(`targets.wechat.resourcePacks.${name}.delivery must be subpackage or remote.`);
+    }));
+}
+function parseTargets(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    const targets = assertRecord(value, 'targets');
+    if (targets.wechat === undefined) {
+        return {};
+    }
+    const wechat = assertRecord(targets.wechat, 'targets.wechat');
+    const outDir = normalizeProjectChildPath(wechat.outDir, 'targets.wechat.outDir');
+    return {
+        wechat: {
+            entry: normalizeProjectPath(wechat.entry, 'targets.wechat.entry'),
+            configDir: normalizeProjectPath(wechat.configDir, 'targets.wechat.configDir'),
+            outDir,
+            resourcePacks: parseWechatResourcePacks(wechat.resourcePacks),
+        },
+    };
+}
 export function parsePixifactProjectConfig(value) {
     const config = assertRecord(value, 'pixifact.project.json');
     if (config.version !== 1) {
         throw new Error('pixifact.project.json version must be 1.');
     }
+    const resourcePacks = parseResourcePacks(config.resourcePacks);
+    const targets = parseTargets(config.targets);
+    for (const name of Object.keys(targets?.wechat?.resourcePacks ?? {})) {
+        if (!resourcePacks?.[name]) {
+            throw new Error(`targets.wechat.resourcePacks.${name} must reference resourcePacks.${name}.`);
+        }
+    }
     return {
         version: 1,
         name: assertString(config.name, 'name'),
         resolution: parseResolution(config.resolution),
         viewport: parseViewport(config.viewport),
         scenes: parseScenes(config.scenes),
+        ...(resourcePacks === undefined ? {} : { resourcePacks }),
+        ...(targets === undefined ? {} : { targets }),
         run: parseRun(config.run),
     };
 }
@@ -117,6 +184,8 @@ export function summarizePixifactProjectConfig(config) {
         resolution: config.resolution,
         viewport: config.viewport,
         scenes: config.scenes,
+        ...(config.resourcePacks === undefined ? {} : { resourcePacks: config.resourcePacks }),
+        ...(config.targets === undefined ? {} : { targets: config.targets }),
         ...(config.run === undefined ? {} : { run: config.run }),
     };
 }

package/dist/runtime/BitmapLabel.d.ts

@@ -0,0 +1,9 @@
+import { BitmapText } from 'pixi.js';
+import { TextBoxControl, type TextBoxAlign, type TextBoxFontWeight, type TextBoxOptions, type TextBoxOverflow } from './TextBoxControl.js';
+export type BitmapLabelAlign = TextBoxAlign;
+export type BitmapLabelOverflow = TextBoxOverflow;
+export type BitmapLabelFontWeight = TextBoxFontWeight;
+export type BitmapLabelOptions = TextBoxOptions;
+export declare class BitmapLabel extends TextBoxControl<BitmapText> {
+    constructor(options?: BitmapLabelOptions);
+}

package/dist/runtime/BitmapLabel.js

@@ -0,0 +1,7 @@
+import { BitmapText } from 'pixi.js';
+import { TextBoxControl, } from './TextBoxControl.js';
+export class BitmapLabel extends TextBoxControl {
+    constructor(options = {}) {
+        super(options, (textOptions) => new BitmapText(textOptions));
+    }
+}

package/dist/runtime/Label.d.ts

@@ -0,0 +1,9 @@
+import { Text } from 'pixi.js';
+import { TextBoxControl, type TextBoxAlign, type TextBoxFontWeight, type TextBoxOptions, type TextBoxOverflow } from './TextBoxControl.js';
+export type LabelAlign = TextBoxAlign;
+export type LabelOverflow = TextBoxOverflow;
+export type LabelFontWeight = TextBoxFontWeight;
+export type LabelOptions = TextBoxOptions;
+export declare class Label extends TextBoxControl<Text> {
+    constructor(options?: LabelOptions);
+}

package/dist/runtime/Label.js

@@ -0,0 +1,7 @@
+import { Text } from 'pixi.js';
+import { TextBoxControl, } from './TextBoxControl.js';
+export class Label extends TextBoxControl {
+    constructor(options = {}) {
+        super(options, (textOptions) => new Text(textOptions));
+    }
+}

package/dist/runtime/ScrollContainer.d.ts

@@ -1,6 +1,7 @@
 import { Container, type ContainerChild, type DestroyOptions } from 'pixi.js';
 import { Control } from './Control.js';
 import type { GroupOptions } from './Group.js';
+import { runtimeBehavior } from './runtimeBehavior.js';
 export type ScrollDirection = 'vertical' | 'horizontal' | 'both';
 export type ScrollContainerOptions = GroupOptions & {
     direction?: ScrollDirection;
@@ -11,6 +12,7 @@ export declare class ScrollContainer extends Control {
     #private;
     readonly contentLayer: Container<ContainerChild>;
     constructor(options?: ScrollContainerOptions);
+    [runtimeBehavior](): void;
     get direction(): ScrollDirection;
     set direction(value: ScrollDirection);
     get scrollX(): number;

package/dist/runtime/ScrollContainer.js

@@ -1,5 +1,6 @@
 import { Container, Graphics, Ticker, } from 'pixi.js';
 import { Control } from './Control.js';
+import { runtimeBehavior } from './runtimeBehavior.js';
 const elasticResistance = 0.5;
 const inertiaFriction = 0.92;
 const springStrength = 0.18;
@@ -26,19 +27,21 @@ export class ScrollContainer extends Control {
         this.#direction = direction ?? this.#direction;
         this.#targetScrollX = scrollX ?? this.#targetScrollX;
         this.#targetScrollY = scrollY ?? this.#targetScrollY;
-        this.eventMode = 'static';
         this.contentLayer.mask = this.#mask;
         this.contentLayer.on('childAdded', this.#handleContentChildAdded, this);
         this.contentLayer.on('childRemoved', this.#handleContentChildRemoved, this);
         super.addChild(this.contentLayer);
         super.addChild(this.#mask);
+        this.layout();
+    }
+    [runtimeBehavior]() {
+        this.eventMode = 'static';
         this.on('wheel', this.#handleWheel, this);
         this.on('pointerdown', this.#handlePointerDown, this);
         this.on('globalpointermove', this.#handleGlobalPointerMove, this);
         this.on('pointerup', this.#handlePointerUp, this);
         this.on('pointerupoutside', this.#handlePointerUp, this);
         this.on('pointercancel', this.#handlePointerUp, this);
-        this.layout();
     }
     get direction() {
         return this.#direction;
@@ -116,6 +119,13 @@ export class ScrollContainer extends Control {
     destroy(options) {
         this.#destroying = true;
         this.#stopMomentum();
+        this.#drag = undefined;
+        this.off('wheel', this.#handleWheel, this);
+        this.off('pointerdown', this.#handlePointerDown, this);
+        this.off('globalpointermove', this.#handleGlobalPointerMove, this);
+        this.off('pointerup', this.#handlePointerUp, this);
+        this.off('pointerupoutside', this.#handlePointerUp, this);
+        this.off('pointercancel', this.#handlePointerUp, this);
         this.contentLayer.off('childAdded', this.#handleContentChildAdded, this);
         this.contentLayer.off('childRemoved', this.#handleContentChildRemoved, this);
         for (const child of this.#watchedContent) {

package/dist/runtime/TextBoxControl.d.ts

@@ -0,0 +1,48 @@
+import { BitmapText, Text, type TextOptions } from 'pixi.js';
+import { Control } from './Control.js';
+import type { GroupOptions } from './Group.js';
+export type TextBoxAlign = 'start' | 'center' | 'end';
+export type TextBoxOverflow = 'visible' | 'clip';
+export type TextBoxFontWeight = 400 | 500 | 600 | 700 | '400' | '500' | '600' | '700' | 'bold';
+export type TextBoxOptions = GroupOptions & {
+    text?: string;
+    fontFamily?: string;
+    fontSize?: number;
+    fontWeight?: TextBoxFontWeight;
+    fill?: number;
+    lineHeight?: number;
+    letterSpacing?: number;
+    wordWrap?: boolean;
+    alignX?: TextBoxAlign;
+    alignY?: TextBoxAlign;
+    overflow?: TextBoxOverflow;
+};
+type TextBoxRenderer = Text | BitmapText;
+export declare class TextBoxControl<T extends TextBoxRenderer> extends Control {
+    #private;
+    constructor(options: TextBoxOptions, createTextNode: (options: TextOptions) => T);
+    get text(): string;
+    set text(value: string);
+    get fontFamily(): string;
+    set fontFamily(value: string);
+    get fontSize(): number;
+    set fontSize(value: number);
+    get fontWeight(): TextBoxFontWeight;
+    set fontWeight(value: TextBoxFontWeight);
+    get fill(): number;
+    set fill(value: number);
+    get lineHeight(): number;
+    set lineHeight(value: number);
+    get letterSpacing(): number;
+    set letterSpacing(value: number);
+    get wordWrap(): boolean;
+    set wordWrap(value: boolean);
+    get alignX(): TextBoxAlign;
+    set alignX(value: TextBoxAlign);
+    get alignY(): TextBoxAlign;
+    set alignY(value: TextBoxAlign);
+    get overflow(): TextBoxOverflow;
+    set overflow(value: TextBoxOverflow);
+    layout(): void;
+}
+export {};

package/dist/runtime/TextBoxControl.js

@@ -0,0 +1,162 @@
+import { Graphics, } from 'pixi.js';
+import { Control } from './Control.js';
+export class TextBoxControl extends Control {
+    #textNode;
+    #clipMask = new Graphics();
+    #fontFamily = 'Arial';
+    #fontSize = 16;
+    #fontWeight = 400;
+    #fill = 0x111827;
+    #lineHeight = 0;
+    #letterSpacing = 0;
+    #wordWrap = false;
+    #alignX = 'start';
+    #alignY = 'start';
+    #overflow = 'visible';
+    constructor(options, createTextNode) {
+        const { text = 'Text', width = 120, height = 28, fontFamily = 'Arial', fontSize = 16, fontWeight = 400, fill = 0x111827, lineHeight = 0, letterSpacing = 0, wordWrap = false, alignX = 'start', alignY = 'start', overflow = 'visible', ...groupOptions } = options;
+        super({ ...groupOptions, width, height });
+        this.#fontFamily = fontFamily;
+        this.#fontSize = fontSize;
+        this.#fontWeight = fontWeight;
+        this.#fill = fill;
+        this.#lineHeight = lineHeight;
+        this.#letterSpacing = letterSpacing;
+        this.#wordWrap = wordWrap;
+        this.#alignX = alignX;
+        this.#alignY = alignY;
+        this.#overflow = overflow;
+        this.#textNode = createTextNode({
+            text,
+            style: {
+                fontFamily,
+                fontSize,
+                fontWeight: String(fontWeight),
+                fill,
+                lineHeight,
+                letterSpacing,
+                wordWrap,
+                wordWrapWidth: width,
+                align: horizontalTextAlign(alignX),
+            },
+        });
+        super.addChild(this.#textNode, this.#clipMask);
+        this.layout();
+    }
+    get text() {
+        return this.#textNode.text;
+    }
+    set text(value) {
+        this.#textNode.text = value;
+        this.layout();
+    }
+    get fontFamily() {
+        return this.#fontFamily;
+    }
+    set fontFamily(value) {
+        this.#fontFamily = value;
+        this.#textNode.style.fontFamily = value;
+        this.layout();
+    }
+    get fontSize() {
+        return this.#fontSize;
+    }
+    set fontSize(value) {
+        this.#fontSize = value;
+        this.#textNode.style.fontSize = value;
+        this.layout();
+    }
+    get fontWeight() {
+        return this.#fontWeight;
+    }
+    set fontWeight(value) {
+        this.#fontWeight = value;
+        this.#textNode.style.fontWeight = String(value);
+        this.layout();
+    }
+    get fill() {
+        return this.#fill;
+    }
+    set fill(value) {
+        this.#fill = value;
+        this.#textNode.style.fill = value;
+        this.layout();
+    }
+    get lineHeight() {
+        return this.#lineHeight;
+    }
+    set lineHeight(value) {
+        this.#lineHeight = value;
+        this.#textNode.style.lineHeight = value;
+        this.layout();
+    }
+    get letterSpacing() {
+        return this.#letterSpacing;
+    }
+    set letterSpacing(value) {
+        this.#letterSpacing = value;
+        this.#textNode.style.letterSpacing = value;
+        this.layout();
+    }
+    get wordWrap() {
+        return this.#wordWrap;
+    }
+    set wordWrap(value) {
+        this.#wordWrap = value;
+        this.#textNode.style.wordWrap = value;
+        this.layout();
+    }
+    get alignX() {
+        return this.#alignX;
+    }
+    set alignX(value) {
+        this.#alignX = value;
+        this.#textNode.style.align = horizontalTextAlign(value);
+        this.layout();
+    }
+    get alignY() {
+        return this.#alignY;
+    }
+    set alignY(value) {
+        this.#alignY = value;
+        this.layout();
+    }
+    get overflow() {
+        return this.#overflow;
+    }
+    set overflow(value) {
+        this.#overflow = value;
+        this.layout();
+    }
+    layout() {
+        super.layout();
+        if (!this.#textNode) {
+            return;
+        }
+        this.#textNode.style.wordWrapWidth = this.width;
+        this.#textNode.anchor.set(alignmentFactor(this.#alignX), alignmentFactor(this.#alignY));
+        this.#textNode.position.set(this.width * alignmentFactor(this.#alignX), this.height * alignmentFactor(this.#alignY));
+        this.#clipMask.clear().rect(0, 0, this.width, this.height).fill(0xffffff);
+        const clip = this.#overflow === 'clip';
+        this.#clipMask.visible = clip;
+        this.#textNode.mask = clip ? this.#clipMask : null;
+    }
+}
+function horizontalTextAlign(align) {
+    if (align === 'center') {
+        return 'center';
+    }
+    if (align === 'end') {
+        return 'right';
+    }
+    return 'left';
+}
+function alignmentFactor(align) {
+    if (align === 'center') {
+        return 0.5;
+    }
+    if (align === 'end') {
+        return 1;
+    }
+    return 0;
+}

package/dist/runtime/index.d.ts

@@ -1,5 +1,7 @@
 export * from './Group.js';
 export * from './Control.js';
+export * from './Label.js';
+export * from './BitmapLabel.js';
 export * from './Rect.js';
 export * from './Image.js';
 export * from './NineImage.js';

package/dist/runtime/index.js

@@ -1,5 +1,7 @@
 export * from './Group.js';
 export * from './Control.js';
+export * from './Label.js';
+export * from './BitmapLabel.js';
 export * from './Rect.js';
 export * from './Image.js';
 export * from './NineImage.js';

package/dist/runtime/runtimeBehavior.d.ts

@@ -0,0 +1,3 @@
+import type { Container } from 'pixi.js';
+export declare const runtimeBehavior: unique symbol;
+export declare function activateRuntimeTree(root: Container): void;

package/dist/runtime/runtimeBehavior.js

@@ -0,0 +1,11 @@
+export const runtimeBehavior = Symbol('pixifact.runtimeBehavior');
+const activatedContainers = new WeakSet();
+export function activateRuntimeTree(root) {
+    if (runtimeBehavior in root && !activatedContainers.has(root)) {
+        activatedContainers.add(root);
+        root[runtimeBehavior]();
+    }
+    for (const child of root.children) {
+        activateRuntimeTree(child);
+    }
+}

package/dist/{compiler → scene}/decorators.d.ts

@@ -1,6 +1,7 @@
-import type { SceneClassDecorator, SceneEventDecoratorOptions, SceneMemberDecorator, ScenePartDecoratorOptions, ScenePropDecoratorOptions, SceneSlotDecoratorOptions } from './spec.js';
+import type { SceneClassDecorator, SceneEventDecoratorOptions, SceneMemberDecorator, ScenePartDecoratorOptions, ScenePropDecoratorOptions, SceneSlotDecoratorOptions, SceneVariants } from '../compiler/spec.js';
 export declare function scene(): SceneClassDecorator;
 export declare function prop(options: ScenePropDecoratorOptions): SceneMemberDecorator;
+export declare function defineVariants<const TVariants extends SceneVariants>(variants: TVariants): TVariants;
 export declare function event(_options?: SceneEventDecoratorOptions): SceneMemberDecorator;
 export declare function slot(options?: SceneSlotDecoratorOptions): SceneMemberDecorator;
 export declare function part(options?: ScenePartDecoratorOptions): SceneMemberDecorator;

package/dist/{compiler → scene}/decorators.js

@@ -1,15 +1,21 @@
+import { activateRuntimeTree } from '../runtime/runtimeBehavior.js';
 import { mountSceneClass } from './sceneRuntime.js';
+import { initializeSceneProps } from './sceneBindingRuntime.js';
 const metadataByConstructor = new WeakMap();
 export function scene() {
     return ((constructor) => {
         const SceneClass = class extends constructor {
             constructor(...args) {
-                super(...args);
+                super();
                 if (new.target !== SceneClass) {
                     return;
                 }
-                const result = mountSceneClass(this, SceneClass);
                 const metadata = sceneMetadata(constructor);
+                const initialProps = args[0] && typeof args[0] === 'object'
+                    ? args[0]
+                    : {};
+                initializeSceneProps(this, metadata.props, initialProps);
+                const result = mountSceneClass(this, SceneClass);
                 for (const [property, id] of metadata.parts) {
                     Object.defineProperty(this, property, {
                         configurable: true,
@@ -26,11 +32,7 @@ export function scene() {
                         writable: false,
                     });
                 }
-                for (const [property, propOptions] of metadata.props) {
-                    if (propOptions.default !== undefined) {
-                        this[property] = propOptions.default;
-                    }
-                }
+                activateRuntimeTree(this);
                 const ready = this.onMounted;
                 if (ready) {
                     ready.call(this);
@@ -46,6 +48,9 @@ export function prop(options) {
         sceneMetadata(target.constructor).props.set(memberName(propertyKey), options);
     });
 }
+export function defineVariants(variants) {
+    return variants;
+}
 export function event(_options = {}) {
     return noopMemberDecorator;
 }

package/dist/scene/index.d.ts

@@ -0,0 +1,6 @@
+export * from './decorators.js';
+export * from './eventRuntime.js';
+export * from './sceneAssetRuntime.js';
+export * from './sceneBindingRuntime.js';
+export * from './sceneRuntime.js';
+export * from './slotRuntime.js';

package/dist/scene/index.js

@@ -0,0 +1,6 @@
+export * from './decorators.js';
+export * from './eventRuntime.js';
+export * from './sceneAssetRuntime.js';
+export * from './sceneBindingRuntime.js';
+export * from './sceneRuntime.js';
+export * from './slotRuntime.js';