pixifact 0.3.0 → 0.5.0

package/dist/{compiler → compiler-node}/scriptInterfaceExtractor.js

@@ -15,6 +15,7 @@ function extractSceneScriptClasses(source, fileName, options) {
     const sourceId = normalizeScriptSourceId(fileName);
     const imports = collectNamedImports(sourceFile, sourceId);
     const structClasses = collectStructClasses(sourceFile);
+    const variantDeclarations = collectVariantDeclarations(sourceFile);
     const classes = [];
     for (const statement of sourceFile.statements) {
         if (!ts.isClassDeclaration(statement)) {
@@ -42,7 +43,8 @@ function extractSceneScriptClasses(source, fileName, options) {
             }
             const prop = memberDecoratorOptions(member, 'prop');
             if (prop) {
-                props[name] = propContract(prop, structClasses);
+                assertStaticPropMember(member, name);
+                props[name] = propContract(prop, member, structClasses, variantDeclarations);
             }
             const event = memberDecoratorOptions(member, 'event');
             if (event) {
@@ -318,6 +320,88 @@ function memberName(name) {
     }
     return undefined;
 }
+function collectVariantDeclarations(sourceFile) {
+    const variants = new Map();
+    for (const statement of sourceFile.statements) {
+        if (!ts.isVariableStatement(statement)) {
+            continue;
+        }
+        for (const declaration of statement.declarationList.declarations) {
+            if (!ts.isIdentifier(declaration.name) || !declaration.initializer) {
+                continue;
+            }
+            const initializer = unwrapExpression(declaration.initializer);
+            if (!ts.isCallExpression(initializer)
+                || !ts.isIdentifier(initializer.expression)
+                || initializer.expression.text !== 'defineVariants') {
+                continue;
+            }
+            if (initializer.arguments.length !== 1) {
+                throw new Error('defineVariants accepts exactly one argument.');
+            }
+            variants.set(declaration.name.text, variantObjectValue(initializer.arguments[0], 'defineVariants argument'));
+        }
+    }
+    return variants;
+}
+function variantObjectValue(expression, label) {
+    const object = unwrapExpression(expression);
+    if (!ts.isObjectLiteralExpression(object)) {
+        throw new Error(`${label} must be an object literal.`);
+    }
+    const variants = {};
+    let expectedFields;
+    for (const property of object.properties) {
+        if (!ts.isPropertyAssignment(property)) {
+            throw new Error(`${label} only supports property assignments.`);
+        }
+        const name = memberName(property.name);
+        if (!name) {
+            throw new Error(`${label} only supports literal case names.`);
+        }
+        const caseExpression = unwrapExpression(property.initializer);
+        if (!ts.isObjectLiteralExpression(caseExpression)) {
+            throw new Error(`${label}.${name} must be an object literal.`);
+        }
+        const fields = {};
+        for (const field of caseExpression.properties) {
+            if (!ts.isPropertyAssignment(field)) {
+                throw new Error(`${label}.${name} only supports property assignments.`);
+            }
+            const fieldName = memberName(field.name);
+            if (!fieldName) {
+                throw new Error(`${label}.${name} only supports literal field names.`);
+            }
+            fields[fieldName] = literalValue(field.initializer, `${label}.${name}.${fieldName}`);
+        }
+        const fieldTypes = Object.fromEntries(Object.entries(fields).map(([field, value]) => [field, typeof value]));
+        if (!expectedFields) {
+            expectedFields = fieldTypes;
+        }
+        else if (!sameFieldTypes(expectedFields, fieldTypes)) {
+            throw new Error(`defineVariants case "${name}" must contain the same fields and field types as the first case.`);
+        }
+        variants[name] = fields;
+    }
+    if (Object.keys(variants).length === 0) {
+        throw new Error('defineVariants requires at least one case.');
+    }
+    return variants;
+}
+function sameFieldTypes(left, right) {
+    const leftEntries = Object.entries(left);
+    return leftEntries.length === Object.keys(right).length
+        && leftEntries.every(([name, type]) => right[name] === type);
+}
+function unwrapExpression(expression) {
+    if (ts.isAsExpression(expression)
+        || ts.isTypeAssertionExpression(expression)
+        || ts.isSatisfiesExpression(expression)
+        || ts.isParenthesizedExpression(expression)) {
+        return unwrapExpression(expression.expression);
+    }
+    return expression;
+}
 function collectStructClasses(sourceFile) {
     const classes = new Map();
     for (const statement of sourceFile.statements) {
@@ -355,65 +439,113 @@ function structFields(node) {
     }
     return fields;
 }
-function propContract(prop, structClasses) {
-    const type = prop.type;
-    const defaultValue = prop.default;
-    if (type === 'string' || type === 'number' || type === 'boolean') {
-        throw new Error('@prop type must be String, Number, Boolean, or a struct class.');
+function assertStaticPropMember(member, name) {
+    const isDeclareProperty = ts.isPropertyDeclaration(member)
+        && member.modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.DeclareKeyword)
+        && !member.modifiers.some((modifier) => modifier.kind === ts.SyntaxKind.AccessorKeyword)
+        && !member.initializer;
+    if (!isDeclareProperty) {
+        throw new Error(`@prop "${name}" must decorate a declare property without an initializer.`);
+    }
+    if (!member.type) {
+        throw new Error(`@prop "${name}" requires an explicit TypeScript property type.`);
+    }
+}
+function propContract(prop, member, structClasses, variantDeclarations) {
+    if (!ts.isPropertyDeclaration(member) || !member.type) {
+        throw new Error('@prop requires a typed declare property.');
     }
-    if (!isIdentifierValue(type)) {
-        throw new Error('@prop type must be String, Number, Boolean, or a struct class.');
+    if (prop.type !== undefined) {
+        throw new Error('@prop type is inferred from the TypeScript property declaration; remove the type option.');
+    }
+    const defaultValue = prop.default;
+    const variantsReference = prop.variants;
+    if (variantsReference !== undefined) {
+        if (!isIdentifierValue(variantsReference)) {
+            throw new Error('@prop variants must reference a local defineVariants declaration.');
+        }
+        const variants = variantDeclarations.get(variantsReference.text);
+        if (!variants) {
+            throw new Error(`@prop variants "${variantsReference.text}" must reference a local defineVariants declaration.`);
+        }
+        if (typeof defaultValue !== 'string' || !variants[defaultValue]) {
+            throw new Error('@prop Variant default must name an existing defineVariants case.');
+        }
+        assertVariantPropertyType(member.type, variantsReference.text);
+        return {
+            type: 'variant',
+            default: defaultValue,
+            variants,
+        };
     }
-    const primitiveType = primitiveConstructorType(type.text);
+    const primitiveType = primitivePropertyType(member.type);
     if (primitiveType) {
         if (defaultValue !== undefined && (!isSceneTemplateScalarValue(defaultValue) || sceneTemplateScalarType(defaultValue) !== primitiveType)) {
-            throw new Error(`@prop default for ${type.text} must be a ${primitiveType} literal.`);
+            throw new Error(`@prop default must be a ${primitiveType} literal.`);
         }
         return {
             type: primitiveType,
             ...(defaultValue !== undefined ? { default: defaultValue } : {}),
         };
     }
-    const structClass = structClasses.get(type.text);
+    const structName = typeReferenceName(member.type);
+    if (!structName) {
+        throw new Error('@prop type must be string, number, boolean, a local struct class, or keyof a local defineVariants declaration.');
+    }
+    const structClass = structClasses.get(structName);
     if (!structClass) {
-        throw new Error(`Struct prop type ${type.text} was not found.`);
+        throw new Error(`Struct prop type ${structName} was not found.`);
     }
     if (!structClass.exported) {
-        throw new Error(`Struct prop type ${type.text} must be exported.`);
+        throw new Error(`Struct prop type ${structName} must be exported.`);
     }
     if (defaultValue !== undefined) {
         throw new Error('@prop default is only supported for primitive props.');
     }
     const struct = structContractInfo(structClass.node);
     if (struct.hasRequiredConstructorParameters) {
-        throw new Error(`Struct prop type ${type.text} must be constructable with no required parameters.`);
+        throw new Error(`Struct prop type ${structName} must be constructable with no required parameters.`);
     }
     return {
         type: 'struct',
-        struct: type.text,
+        struct: structName,
         fields: struct.fields,
     };
 }
-function structContractInfo(node) {
-    return {
-        fields: structFields(node),
-        hasRequiredConstructorParameters: node.members.some((member) => ts.isConstructorDeclaration(member) && member.parameters.some((parameter) => !parameter.questionToken && !parameter.initializer)),
-    };
+function assertVariantPropertyType(type, variantsName) {
+    if (!ts.isTypeOperatorNode(type)
+        || type.operator !== ts.SyntaxKind.KeyOfKeyword
+        || !ts.isTypeQueryNode(type.type)
+        || !ts.isIdentifier(type.type.exprName)
+        || type.type.exprName.text !== variantsName) {
+        throw new Error(`@prop Variant type must be "keyof typeof ${variantsName}".`);
+    }
 }
-function primitiveConstructorType(name) {
-    if (name === 'String') {
+function primitivePropertyType(type) {
+    if (type.kind === ts.SyntaxKind.StringKeyword) {
         return 'string';
     }
-    if (name === 'Number') {
+    if (type.kind === ts.SyntaxKind.NumberKeyword) {
         return 'number';
     }
-    if (name === 'Boolean') {
+    if (type.kind === ts.SyntaxKind.BooleanKeyword) {
         return 'boolean';
     }
     return undefined;
 }
+function typeReferenceName(type) {
+    return ts.isTypeReferenceNode(type) && ts.isIdentifier(type.typeName)
+        ? type.typeName.text
+        : undefined;
+}
+function structContractInfo(node) {
+    return {
+        fields: structFields(node),
+        hasRequiredConstructorParameters: node.members.some((member) => ts.isConstructorDeclaration(member) && member.parameters.some((parameter) => !parameter.questionToken && !parameter.initializer)),
+    };
+}
 function isIdentifierValue(value) {
-    return ts.isIdentifier(value);
+    return typeof value === 'object' && ts.isIdentifier(value);
 }
 function isSceneTemplateScalarValue(value) {
     return typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean';

package/dist/compiler-node/vite.d.ts

@@ -4,5 +4,6 @@ export interface PixifactScenesPluginOptions {
 }
 export declare function pixifactScenesPlugin(options?: PixifactScenesPluginOptions): {
     name: string;
-    resolveId(id: string): string | undefined;
+    resolveId(id: string): "\0pixifact:scenes" | undefined;
+    load(id: string): Promise<string | undefined>;
 };

package/dist/compiler-node/vite.js

@@ -1,5 +1,7 @@
+import { readFile } from 'node:fs/promises';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { generatedSceneAssetsFileName } from '../compiler/compileScenes.js';
 function projectRootPath(projectRoot) {
     if (typeof projectRoot === 'string') {
         return projectRoot;
@@ -10,12 +12,37 @@ function projectRootPath(projectRoot) {
     return process.cwd();
 }
 export function pixifactScenesPlugin(options = {}) {
-    const generatedDir = path.resolve(projectRootPath(options.projectRoot), options.generatedDir ?? '.pixifact/generated');
+    const projectRoot = projectRootPath(options.projectRoot);
+    const generatedDir = path.resolve(projectRoot, options.generatedDir ?? '.pixifact/generated');
     const sceneRegistry = path.join(generatedDir, 'scenes.generated.ts');
+    const sceneAssets = path.join(generatedDir, generatedSceneAssetsFileName);
+    const virtualSceneRegistry = '\0pixifact:scenes';
     return {
         name: 'pixifact-scenes',
         resolveId(id) {
-            return id === 'pixifact:scenes' ? sceneRegistry : undefined;
+            return id === 'pixifact:scenes' ? virtualSceneRegistry : undefined;
+        },
+        async load(id) {
+            if (id !== virtualSceneRegistry) {
+                return undefined;
+            }
+            const assets = JSON.parse(await readFile(sceneAssets, 'utf8'));
+            const imports = assets.map((asset, index) => `import __pixifactAsset${index + 1} from ${JSON.stringify(viteFileImport(path.resolve(projectRoot, asset), '?url'))};`);
+            const manifest = Object.fromEntries(assets.map((asset, index) => [
+                asset,
+                { src: `__pixifactAsset${index + 1}` },
+            ]));
+            const manifestSource = JSON.stringify(manifest, null, 2)
+                .replace(/"src": "(__pixifactAsset\d+)"/g, '"src": $1');
+            return [
+                ...imports,
+                "import { configureSceneAssets } from 'pixifact/scene';",
+                `import ${JSON.stringify(viteFileImport(sceneRegistry))};`,
+                `configureSceneAssets(${manifestSource});`,
+            ].join('\n');
         },
     };
 }
+function viteFileImport(filePath, suffix = '') {
+    return `/@fs/${filePath.replaceAll(path.sep, '/')}${suffix}`;
+}

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

@@ -0,0 +1,316 @@
+import { fetchWechatResource } from './fetch.js';
+import type { WechatRuntime } from './runtime.js';
+export declare function createWechatPixiAdapter(runtime: WechatRuntime): {
+    createCanvas(width?: number, height?: number): import("./types").WechatCanvas;
+    createImage: () => import("./types").WechatImage;
+    getCanvasRenderingContext2D: () => ObjectConstructor;
+    getWebGLRenderingContext: () => {
+        new (): WebGLRenderingContext;
+        prototype: WebGLRenderingContext;
+        readonly DEPTH_BUFFER_BIT: 256;
+        readonly STENCIL_BUFFER_BIT: 1024;
+        readonly COLOR_BUFFER_BIT: 16384;
+        readonly POINTS: 0;
+        readonly LINES: 1;
+        readonly LINE_LOOP: 2;
+        readonly LINE_STRIP: 3;
+        readonly TRIANGLES: 4;
+        readonly TRIANGLE_STRIP: 5;
+        readonly TRIANGLE_FAN: 6;
+        readonly ZERO: 0;
+        readonly ONE: 1;
+        readonly SRC_COLOR: 768;
+        readonly ONE_MINUS_SRC_COLOR: 769;
+        readonly SRC_ALPHA: 770;
+        readonly ONE_MINUS_SRC_ALPHA: 771;
+        readonly DST_ALPHA: 772;
+        readonly ONE_MINUS_DST_ALPHA: 773;
+        readonly DST_COLOR: 774;
+        readonly ONE_MINUS_DST_COLOR: 775;
+        readonly SRC_ALPHA_SATURATE: 776;
+        readonly FUNC_ADD: 32774;
+        readonly BLEND_EQUATION: 32777;
+        readonly BLEND_EQUATION_RGB: 32777;
+        readonly BLEND_EQUATION_ALPHA: 34877;
+        readonly FUNC_SUBTRACT: 32778;
+        readonly FUNC_REVERSE_SUBTRACT: 32779;
+        readonly BLEND_DST_RGB: 32968;
+        readonly BLEND_SRC_RGB: 32969;
+        readonly BLEND_DST_ALPHA: 32970;
+        readonly BLEND_SRC_ALPHA: 32971;
+        readonly CONSTANT_COLOR: 32769;
+        readonly ONE_MINUS_CONSTANT_COLOR: 32770;
+        readonly CONSTANT_ALPHA: 32771;
+        readonly ONE_MINUS_CONSTANT_ALPHA: 32772;
+        readonly BLEND_COLOR: 32773;
+        readonly ARRAY_BUFFER: 34962;
+        readonly ELEMENT_ARRAY_BUFFER: 34963;
+        readonly ARRAY_BUFFER_BINDING: 34964;
+        readonly ELEMENT_ARRAY_BUFFER_BINDING: 34965;
+        readonly STREAM_DRAW: 35040;
+        readonly STATIC_DRAW: 35044;
+        readonly DYNAMIC_DRAW: 35048;
+        readonly BUFFER_SIZE: 34660;
+        readonly BUFFER_USAGE: 34661;
+        readonly CURRENT_VERTEX_ATTRIB: 34342;
+        readonly FRONT: 1028;
+        readonly BACK: 1029;
+        readonly FRONT_AND_BACK: 1032;
+        readonly CULL_FACE: 2884;
+        readonly BLEND: 3042;
+        readonly DITHER: 3024;
+        readonly STENCIL_TEST: 2960;
+        readonly DEPTH_TEST: 2929;
+        readonly SCISSOR_TEST: 3089;
+        readonly POLYGON_OFFSET_FILL: 32823;
+        readonly SAMPLE_ALPHA_TO_COVERAGE: 32926;
+        readonly SAMPLE_COVERAGE: 32928;
+        readonly NO_ERROR: 0;
+        readonly INVALID_ENUM: 1280;
+        readonly INVALID_VALUE: 1281;
+        readonly INVALID_OPERATION: 1282;
+        readonly OUT_OF_MEMORY: 1285;
+        readonly CW: 2304;
+        readonly CCW: 2305;
+        readonly LINE_WIDTH: 2849;
+        readonly ALIASED_POINT_SIZE_RANGE: 33901;
+        readonly ALIASED_LINE_WIDTH_RANGE: 33902;
+        readonly CULL_FACE_MODE: 2885;
+        readonly FRONT_FACE: 2886;
+        readonly DEPTH_RANGE: 2928;
+        readonly DEPTH_WRITEMASK: 2930;
+        readonly DEPTH_CLEAR_VALUE: 2931;
+        readonly DEPTH_FUNC: 2932;
+        readonly STENCIL_CLEAR_VALUE: 2961;
+        readonly STENCIL_FUNC: 2962;
+        readonly STENCIL_FAIL: 2964;
+        readonly STENCIL_PASS_DEPTH_FAIL: 2965;
+        readonly STENCIL_PASS_DEPTH_PASS: 2966;
+        readonly STENCIL_REF: 2967;
+        readonly STENCIL_VALUE_MASK: 2963;
+        readonly STENCIL_WRITEMASK: 2968;
+        readonly STENCIL_BACK_FUNC: 34816;
+        readonly STENCIL_BACK_FAIL: 34817;
+        readonly STENCIL_BACK_PASS_DEPTH_FAIL: 34818;
+        readonly STENCIL_BACK_PASS_DEPTH_PASS: 34819;
+        readonly STENCIL_BACK_REF: 36003;
+        readonly STENCIL_BACK_VALUE_MASK: 36004;
+        readonly STENCIL_BACK_WRITEMASK: 36005;
+        readonly VIEWPORT: 2978;
+        readonly SCISSOR_BOX: 3088;
+        readonly COLOR_CLEAR_VALUE: 3106;
+        readonly COLOR_WRITEMASK: 3107;
+        readonly UNPACK_ALIGNMENT: 3317;
+        readonly PACK_ALIGNMENT: 3333;
+        readonly MAX_TEXTURE_SIZE: 3379;
+        readonly MAX_VIEWPORT_DIMS: 3386;
+        readonly SUBPIXEL_BITS: 3408;
+        readonly RED_BITS: 3410;
+        readonly GREEN_BITS: 3411;
+        readonly BLUE_BITS: 3412;
+        readonly ALPHA_BITS: 3413;
+        readonly DEPTH_BITS: 3414;
+        readonly STENCIL_BITS: 3415;
+        readonly POLYGON_OFFSET_UNITS: 10752;
+        readonly POLYGON_OFFSET_FACTOR: 32824;
+        readonly TEXTURE_BINDING_2D: 32873;
+        readonly SAMPLE_BUFFERS: 32936;
+        readonly SAMPLES: 32937;
+        readonly SAMPLE_COVERAGE_VALUE: 32938;
+        readonly SAMPLE_COVERAGE_INVERT: 32939;
+        readonly COMPRESSED_TEXTURE_FORMATS: 34467;
+        readonly DONT_CARE: 4352;
+        readonly FASTEST: 4353;
+        readonly NICEST: 4354;
+        readonly GENERATE_MIPMAP_HINT: 33170;
+        readonly BYTE: 5120;
+        readonly UNSIGNED_BYTE: 5121;
+        readonly SHORT: 5122;
+        readonly UNSIGNED_SHORT: 5123;
+        readonly INT: 5124;
+        readonly UNSIGNED_INT: 5125;
+        readonly FLOAT: 5126;
+        readonly DEPTH_COMPONENT: 6402;
+        readonly ALPHA: 6406;
+        readonly RGB: 6407;
+        readonly RGBA: 6408;
+        readonly LUMINANCE: 6409;
+        readonly LUMINANCE_ALPHA: 6410;
+        readonly UNSIGNED_SHORT_4_4_4_4: 32819;
+        readonly UNSIGNED_SHORT_5_5_5_1: 32820;
+        readonly UNSIGNED_SHORT_5_6_5: 33635;
+        readonly FRAGMENT_SHADER: 35632;
+        readonly VERTEX_SHADER: 35633;
+        readonly MAX_VERTEX_ATTRIBS: 34921;
+        readonly MAX_VERTEX_UNIFORM_VECTORS: 36347;
+        readonly MAX_VARYING_VECTORS: 36348;
+        readonly MAX_COMBINED_TEXTURE_IMAGE_UNITS: 35661;
+        readonly MAX_VERTEX_TEXTURE_IMAGE_UNITS: 35660;
+        readonly MAX_TEXTURE_IMAGE_UNITS: 34930;
+        readonly MAX_FRAGMENT_UNIFORM_VECTORS: 36349;
+        readonly SHADER_TYPE: 35663;
+        readonly DELETE_STATUS: 35712;
+        readonly LINK_STATUS: 35714;
+        readonly VALIDATE_STATUS: 35715;
+        readonly ATTACHED_SHADERS: 35717;
+        readonly ACTIVE_UNIFORMS: 35718;
+        readonly ACTIVE_ATTRIBUTES: 35721;
+        readonly SHADING_LANGUAGE_VERSION: 35724;
+        readonly CURRENT_PROGRAM: 35725;
+        readonly NEVER: 512;
+        readonly LESS: 513;
+        readonly EQUAL: 514;
+        readonly LEQUAL: 515;
+        readonly GREATER: 516;
+        readonly NOTEQUAL: 517;
+        readonly GEQUAL: 518;
+        readonly ALWAYS: 519;
+        readonly KEEP: 7680;
+        readonly REPLACE: 7681;
+        readonly INCR: 7682;
+        readonly DECR: 7683;
+        readonly INVERT: 5386;
+        readonly INCR_WRAP: 34055;
+        readonly DECR_WRAP: 34056;
+        readonly VENDOR: 7936;
+        readonly RENDERER: 7937;
+        readonly VERSION: 7938;
+        readonly NEAREST: 9728;
+        readonly LINEAR: 9729;
+        readonly NEAREST_MIPMAP_NEAREST: 9984;
+        readonly LINEAR_MIPMAP_NEAREST: 9985;
+        readonly NEAREST_MIPMAP_LINEAR: 9986;
+        readonly LINEAR_MIPMAP_LINEAR: 9987;
+        readonly TEXTURE_MAG_FILTER: 10240;
+        readonly TEXTURE_MIN_FILTER: 10241;
+        readonly TEXTURE_WRAP_S: 10242;
+        readonly TEXTURE_WRAP_T: 10243;
+        readonly TEXTURE_2D: 3553;
+        readonly TEXTURE: 5890;
+        readonly TEXTURE_CUBE_MAP: 34067;
+        readonly TEXTURE_BINDING_CUBE_MAP: 34068;
+        readonly TEXTURE_CUBE_MAP_POSITIVE_X: 34069;
+        readonly TEXTURE_CUBE_MAP_NEGATIVE_X: 34070;
+        readonly TEXTURE_CUBE_MAP_POSITIVE_Y: 34071;
+        readonly TEXTURE_CUBE_MAP_NEGATIVE_Y: 34072;
+        readonly TEXTURE_CUBE_MAP_POSITIVE_Z: 34073;
+        readonly TEXTURE_CUBE_MAP_NEGATIVE_Z: 34074;
+        readonly MAX_CUBE_MAP_TEXTURE_SIZE: 34076;
+        readonly TEXTURE0: 33984;
+        readonly TEXTURE1: 33985;
+        readonly TEXTURE2: 33986;
+        readonly TEXTURE3: 33987;
+        readonly TEXTURE4: 33988;
+        readonly TEXTURE5: 33989;
+        readonly TEXTURE6: 33990;
+        readonly TEXTURE7: 33991;
+        readonly TEXTURE8: 33992;
+        readonly TEXTURE9: 33993;
+        readonly TEXTURE10: 33994;
+        readonly TEXTURE11: 33995;
+        readonly TEXTURE12: 33996;
+        readonly TEXTURE13: 33997;
+        readonly TEXTURE14: 33998;
+        readonly TEXTURE15: 33999;
+        readonly TEXTURE16: 34000;
+        readonly TEXTURE17: 34001;
+        readonly TEXTURE18: 34002;
+        readonly TEXTURE19: 34003;
+        readonly TEXTURE20: 34004;
+        readonly TEXTURE21: 34005;
+        readonly TEXTURE22: 34006;
+        readonly TEXTURE23: 34007;
+        readonly TEXTURE24: 34008;
+        readonly TEXTURE25: 34009;
+        readonly TEXTURE26: 34010;
+        readonly TEXTURE27: 34011;
+        readonly TEXTURE28: 34012;
+        readonly TEXTURE29: 34013;
+        readonly TEXTURE30: 34014;
+        readonly TEXTURE31: 34015;
+        readonly ACTIVE_TEXTURE: 34016;
+        readonly REPEAT: 10497;
+        readonly CLAMP_TO_EDGE: 33071;
+        readonly MIRRORED_REPEAT: 33648;
+        readonly FLOAT_VEC2: 35664;
+        readonly FLOAT_VEC3: 35665;
+        readonly FLOAT_VEC4: 35666;
+        readonly INT_VEC2: 35667;
+        readonly INT_VEC3: 35668;
+        readonly INT_VEC4: 35669;
+        readonly BOOL: 35670;
+        readonly BOOL_VEC2: 35671;
+        readonly BOOL_VEC3: 35672;
+        readonly BOOL_VEC4: 35673;
+        readonly FLOAT_MAT2: 35674;
+        readonly FLOAT_MAT3: 35675;
+        readonly FLOAT_MAT4: 35676;
+        readonly SAMPLER_2D: 35678;
+        readonly SAMPLER_CUBE: 35680;
+        readonly VERTEX_ATTRIB_ARRAY_ENABLED: 34338;
+        readonly VERTEX_ATTRIB_ARRAY_SIZE: 34339;
+        readonly VERTEX_ATTRIB_ARRAY_STRIDE: 34340;
+        readonly VERTEX_ATTRIB_ARRAY_TYPE: 34341;
+        readonly VERTEX_ATTRIB_ARRAY_NORMALIZED: 34922;
+        readonly VERTEX_ATTRIB_ARRAY_POINTER: 34373;
+        readonly VERTEX_ATTRIB_ARRAY_BUFFER_BINDING: 34975;
+        readonly IMPLEMENTATION_COLOR_READ_TYPE: 35738;
+        readonly IMPLEMENTATION_COLOR_READ_FORMAT: 35739;
+        readonly COMPILE_STATUS: 35713;
+        readonly LOW_FLOAT: 36336;
+        readonly MEDIUM_FLOAT: 36337;
+        readonly HIGH_FLOAT: 36338;
+        readonly LOW_INT: 36339;
+        readonly MEDIUM_INT: 36340;
+        readonly HIGH_INT: 36341;
+        readonly FRAMEBUFFER: 36160;
+        readonly RENDERBUFFER: 36161;
+        readonly RGBA4: 32854;
+        readonly RGB5_A1: 32855;
+        readonly RGBA8: 32856;
+        readonly RGB565: 36194;
+        readonly DEPTH_COMPONENT16: 33189;
+        readonly STENCIL_INDEX8: 36168;
+        readonly DEPTH_STENCIL: 34041;
+        readonly RENDERBUFFER_WIDTH: 36162;
+        readonly RENDERBUFFER_HEIGHT: 36163;
+        readonly RENDERBUFFER_INTERNAL_FORMAT: 36164;
+        readonly RENDERBUFFER_RED_SIZE: 36176;
+        readonly RENDERBUFFER_GREEN_SIZE: 36177;
+        readonly RENDERBUFFER_BLUE_SIZE: 36178;
+        readonly RENDERBUFFER_ALPHA_SIZE: 36179;
+        readonly RENDERBUFFER_DEPTH_SIZE: 36180;
+        readonly RENDERBUFFER_STENCIL_SIZE: 36181;
+        readonly FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE: 36048;
+        readonly FRAMEBUFFER_ATTACHMENT_OBJECT_NAME: 36049;
+        readonly FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL: 36050;
+        readonly FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE: 36051;
+        readonly COLOR_ATTACHMENT0: 36064;
+        readonly DEPTH_ATTACHMENT: 36096;
+        readonly STENCIL_ATTACHMENT: 36128;
+        readonly DEPTH_STENCIL_ATTACHMENT: 33306;
+        readonly NONE: 0;
+        readonly FRAMEBUFFER_COMPLETE: 36053;
+        readonly FRAMEBUFFER_INCOMPLETE_ATTACHMENT: 36054;
+        readonly FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT: 36055;
+        readonly FRAMEBUFFER_INCOMPLETE_DIMENSIONS: 36057;
+        readonly FRAMEBUFFER_UNSUPPORTED: 36061;
+        readonly FRAMEBUFFER_BINDING: 36006;
+        readonly RENDERBUFFER_BINDING: 36007;
+        readonly MAX_RENDERBUFFER_SIZE: 34024;
+        readonly INVALID_FRAMEBUFFER_OPERATION: 1286;
+        readonly UNPACK_FLIP_Y_WEBGL: 37440;
+        readonly UNPACK_PREMULTIPLY_ALPHA_WEBGL: 37441;
+        readonly CONTEXT_LOST_WEBGL: 37442;
+        readonly UNPACK_COLORSPACE_CONVERSION_WEBGL: 37443;
+        readonly BROWSER_DEFAULT_WEBGL: 37444;
+    };
+    getNavigator: () => {
+        gpu: null;
+        userAgent: string;
+    };
+    getBaseUrl: () => string;
+    getFontFaceSet: () => null;
+    fetch: typeof fetchWechatResource;
+    parseXML: () => Document;
+};

package/dist/platform/wechat/adapter.js

@@ -0,0 +1,26 @@
+import { fetchWechatResource } from './fetch.js';
+import { wechatApi } from './types.js';
+export function createWechatPixiAdapter(runtime) {
+    const wx = wechatApi();
+    const webGL1Constructor = globalThis.WebGLRenderingContext
+        ?? (runtime.webGLVersion === 1 ? runtime.context.constructor : class WebGLRenderingContextFallback {
+        });
+    return {
+        createCanvas(width = 1, height = 1) {
+            const canvas = wx.createOffscreenCanvas?.({ type: '2d', width, height }) ?? wx.createCanvas();
+            canvas.width = width;
+            canvas.height = height;
+            return canvas;
+        },
+        createImage: () => wx.createImage(),
+        getCanvasRenderingContext2D: () => Object,
+        getWebGLRenderingContext: () => webGL1Constructor,
+        getNavigator: () => ({ gpu: null, userAgent: runtime.userAgent }),
+        getBaseUrl: () => '',
+        getFontFaceSet: () => null,
+        fetch: fetchWechatResource,
+        parseXML: () => {
+            throw new Error('XML parsing is not implemented for the WeChat target.');
+        },
+    };
+}

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

@@ -0,0 +1,32 @@
+import 'pixi.js/unsafe-eval';
+import 'pixi.js/events';
+import { Container, Rectangle, Ticker, WebGLRenderer, type ColorSource, type EventSystemFeatures } from 'pixi.js';
+import { type WechatPointerBinding } from './input.js';
+import { type WechatLifecycleBinding } from './lifecycle.js';
+import { type WechatRuntime } from './runtime.js';
+import type { WechatCanvas } from './types.js';
+export interface WechatPixiApplicationOptions {
+    antialias?: boolean;
+    autoStart?: boolean;
+    backgroundAlpha?: number;
+    backgroundColor?: ColorSource;
+    eventFeatures?: Partial<EventSystemFeatures>;
+    onHide?(): void;
+    onShow?(): void;
+    resolution?: number;
+}
+export interface WechatPixiApplication {
+    readonly canvas: WechatCanvas;
+    destroy(): void;
+    readonly input: WechatPointerBinding;
+    readonly lifecycle: WechatLifecycleBinding;
+    render(): void;
+    readonly renderer: WebGLRenderer;
+    readonly runtime: WechatRuntime;
+    readonly screen: Rectangle;
+    readonly stage: Container;
+    start(): void;
+    stop(): void;
+    readonly ticker: Ticker;
+}
+export declare function createWechatPixiApplication(options?: WechatPixiApplicationOptions): Promise<WechatPixiApplication>;