@safe-engine/pixi 8.10.1 → 8.10.2

package/dist/gui/FancyButtonComp.js

@@ -32,7 +32,7 @@ export class FancyButtonComp extends ComponentX {
         });
         const world = GameWorld.Instance;
         const entity = world.entities.create();
-        entity.assign(new NodeComp(button, entity));
+        this.node = entity.assign(new NodeComp(button, entity));
         const comp = entity.assign(this);
         return comp;
     }

package/dist/gui/ScrollViewComp.d.ts

@@ -1,11 +1,11 @@
-import { FancyButton } from '@pixi/ui';
+import { ScrollBox } from '@pixi/ui';
 import { BaseComponentProps } from '..';
 import { ComponentX } from '../components/BaseComponent';
 interface ScrollViewCompProps extends BaseComponentProps<ScrollViewComp> {
     width: number;
     height: number;
 }
-export declare class ScrollViewComp extends ComponentX<ScrollViewCompProps, FancyButton> {
+export declare class ScrollViewComp extends ComponentX<ScrollViewCompProps, ScrollBox> {
     render(): this;
 }
 export {};

package/dist/gui/ScrollViewComp.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ScrollViewComp.d.ts","sourceRoot":"","sources":["../../src/gui/ScrollViewComp.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAa,MAAM,UAAU,CAAA;AACjD,OAAO,EAAE,kBAAkB,EAAuC,MAAM,IAAI,CAAA;AAC5E,OAAO,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAA;AAExD,UAAU,mBAAoB,SAAQ,kBAAkB,CAAC,cAAc,CAAC;IACtE,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;CACf;AAED,qBAAa,cAAe,SAAQ,UAAU,CAAC,mBAAmB,EAAE,WAAW,CAAC;IAC9E,MAAM;CASP"}
+{"version":3,"file":"ScrollViewComp.d.ts","sourceRoot":"","sources":["../../src/gui/ScrollViewComp.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AACpC,OAAO,EAAE,kBAAkB,EAAuC,MAAM,IAAI,CAAA;AAC5E,OAAO,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAA;AAExD,UAAU,mBAAoB,SAAQ,kBAAkB,CAAC,cAAc,CAAC;IACtE,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;CACf;AAED,qBAAa,cAAe,SAAQ,UAAU,CAAC,mBAAmB,EAAE,SAAS,CAAC;IAC5E,MAAM;CASP"}

package/dist/gui/ScrollViewComp.js

@@ -7,7 +7,7 @@ export class ScrollViewComp extends ComponentX {
         const view = new ScrollBox({ width, height });
         const world = GameWorld.Instance;
         const entity = world.entities.create();
-        entity.assign(new NodeComp(view, entity));
+        this.node = entity.assign(new NodeComp(view, entity));
         const comp = entity.assign(this);
         return comp;
     }

package/dist/packages/pixijs/scripts/index/index.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/packages/pixijs/scripts/index/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../packages/pixijs/scripts/index/index.ts"],"names":[],"mappings":""}

package/dist/packages/pixijs/scripts/index/index.js

@@ -0,0 +1,70 @@
+import fs from 'fs';
+import glob from 'glob';
+import path from 'path';
+const directoryPath = path.join(process.cwd(), './src');
+// find all directories in src
+const directories = glob.sync('*/', { cwd: directoryPath, absolute: true });
+// Use glob to find all TypeScript files recursively in the directory
+directories.forEach((directory) => {
+    const files = glob.sync('**/!(*.d).ts', {
+        cwd: directory,
+        ignore: [
+            '**/init.ts',
+            // for bundles this is not needed, and for normal build it gets added by the browser extension
+            '**/browserAll.ts',
+            // same as above
+            '**/webworkerAll.ts',
+            // these shouldn't be exported as the webworker plugin will handle them
+            '**/*.worker.ts',
+            // Ignore circular imports
+            '**/index.ts',
+            // Tests
+            '**/__tests__/**',
+            // ignore documents
+            '**/_documents/*.md',
+        ],
+    });
+    // Generate export statements for each file
+    const lines = [
+        '// Auto-generated code, do not edit manually',
+        ...files.map((file) => `export * from './${file.replace(/\.ts$/, '')}';`)
+    ];
+    // now grab all vert/frag shaders
+    const shaders = glob.sync('**/*.{vert,frag,glsl,wgsl}', { cwd: directory });
+    // Generate export statements for each shader
+    const shaderExportStatements = shaders.map((file) => {
+        const replace = file.replace(/\.(vert|frag|glsl|wgsl)$/, '');
+        let shortName = path.basename(replace).replace(/-([a-z])/g, (_, group1) => group1.toUpperCase());
+        const ext = path.extname(file).slice(1);
+        shortName += ext.charAt(0).toUpperCase() + ext.slice(1);
+        return `/** @ignore */\nexport { default as ${shortName} } from './${file}';`;
+    });
+    // Combine the export statements into one file
+    lines.push(...shaderExportStatements, '');
+    // Write the export statements to the index.ts file
+    const filePath = path.join(directory, 'index.ts');
+    if (!fs.existsSync(filePath)) {
+        return;
+    }
+    const localFile = path.relative(process.cwd(), filePath);
+    const command = process.argv[2];
+    const output = lines.join('\n');
+    const changed = fs.readFileSync(filePath, 'utf-8') !== output;
+    if (command === '--check') {
+        if (changed) {
+            console.error(`ERROR: File ${localFile} is out of date, run 'npm run build:index' to update it.\n`);
+            process.exit(1);
+        }
+    }
+    else if (command === '--write') {
+        if (changed) {
+            // eslint-disable-next-line no-console
+            console.log(`Updating ${localFile}`);
+            fs.writeFileSync(filePath, output, 'utf-8');
+        }
+    }
+    else {
+        console.error(`ERROR: Invalid command. Use '--check' or '--write'.`);
+        process.exit(1);
+    }
+});

package/dist/packages/pixijs/scripts/jest/jest-global-setup.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=jest-global-setup.d.ts.map

package/dist/packages/pixijs/scripts/jest/jest-global-setup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jest-global-setup.d.ts","sourceRoot":"","sources":["../../../../../packages/pixijs/scripts/jest/jest-global-setup.ts"],"names":[],"mappings":""}

package/dist/packages/pixijs/scripts/jest/jest-global-setup.js

@@ -0,0 +1,35 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { spawn } from 'child_process';
+import { join } from 'path';
+// eslint-disable-next-line func-names
+module.exports = function () {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!process.env.GITHUB_ACTIONS) {
+            const httpServerProcess = spawn('http-server', ['-c-1', `${join(process.cwd(), './')}`], {
+                // See https://nodejs.org/api/child_process.html#spawning-bat-and-cmd-files-on-windows
+                shell: process.platform === 'win32',
+            });
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+            // @ts-ignore
+            globalThis.__SERVER__ = httpServerProcess;
+            // give the server time to start
+            yield new Promise((resolve) => {
+                let data = '';
+                httpServerProcess.stdout.on('data', (chunk) => {
+                    data += chunk;
+                    if (data.includes('Hit CTRL-C to stop the server')) {
+                        resolve();
+                    }
+                });
+            });
+        }
+    });
+};

package/dist/packages/pixijs/scripts/jest/jest-global-teardown.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=jest-global-teardown.d.ts.map

package/dist/packages/pixijs/scripts/jest/jest-global-teardown.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jest-global-teardown.d.ts","sourceRoot":"","sources":["../../../../../packages/pixijs/scripts/jest/jest-global-teardown.ts"],"names":[],"mappings":""}

package/dist/packages/pixijs/scripts/jest/jest-global-teardown.js

@@ -0,0 +1,25 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import kill from 'tree-kill';
+// eslint-disable-next-line func-names
+module.exports = function () {
+    return __awaiter(this, void 0, void 0, function* () {
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        const httpServerProcess = globalThis.__SERVER__;
+        if (httpServerProcess) {
+            const processClose = new Promise((resolve) => {
+                httpServerProcess.on('close', resolve);
+            });
+            kill(httpServerProcess.pid);
+            yield processClose;
+        }
+    });
+};

package/dist/packages/pixijs/scripts/release.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=release.d.ts.map

package/dist/packages/pixijs/scripts/release.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"release.d.ts","sourceRoot":"","sources":["../../../../packages/pixijs/scripts/release.ts"],"names":[],"mappings":""}

package/dist/packages/pixijs/scripts/release.js

@@ -0,0 +1,37 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { readJSON } from 'fs-extra';
+import path from 'path';
+import { bump } from './utils/bump';
+import { spawn } from './utils/spawn';
+/**
+ * Bump the version of all packages in the monorepo
+ * and their dependencies. Replacement for lerna version --exact --force-publish
+ */
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const { version } = yield readJSON(path.join(process.cwd(), 'package.json'));
+            const nextVersion = yield bump(version);
+            // Finish up: update lock, commit and tag the release
+            yield spawn('npm', ['version', nextVersion, '-m', `v${nextVersion}`]);
+            // For testing purposes
+            if (!process.argv.includes('--no-push')) {
+                yield spawn('git', ['push']);
+                yield spawn('git', ['push', '--tags']);
+            }
+        }
+        catch (err) {
+            console.error(err.message);
+            process.exit(1);
+        }
+    });
+}
+void main();

package/dist/packages/pixijs/scripts/types/fixTypes.d.ts

@@ -0,0 +1,10 @@
+/**
+ * -----------------------------------------------------------------
+ * The file is used to fix various issues with the types
+ * - Add reference paths to the mixins
+ * - Copy over the Shaders.d.ts file to the lib folder for
+ *   proper frag,vert,wgsl support
+ * -----------------------------------------------------------------
+ */
+export {};
+//# sourceMappingURL=fixTypes.d.ts.map

package/dist/packages/pixijs/scripts/types/fixTypes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fixTypes.d.ts","sourceRoot":"","sources":["../../../../../packages/pixijs/scripts/types/fixTypes.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG"}

package/dist/packages/pixijs/scripts/types/fixTypes.js

@@ -0,0 +1,47 @@
+/**
+ * -----------------------------------------------------------------
+ * The file is used to fix various issues with the types
+ * - Add reference paths to the mixins
+ * - Copy over the Shaders.d.ts file to the lib folder for
+ *   proper frag,vert,wgsl support
+ * -----------------------------------------------------------------
+ */
+import * as glob from 'glob';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+/**
+ * Get every d.ts file in the src folder and add a
+ * reference path to it in the lib/index.d.ts file
+ *
+ * This allows us to define our PixiMixins in the src folder
+ * e.g. /// <reference path="./app/ApplicationMixins.d.ts" />
+ */
+function addMixinReferencePaths() {
+    // Support windows paths, glob requires only forward slashes
+    const srcPath = path.join(process.cwd(), 'src').replace(/\\/g, '/');
+    const files = glob.sync(`${srcPath}/**/*.d.ts`);
+    const lines = [];
+    files.forEach((file) => {
+        const name = file.split(srcPath)[1];
+        lines.push(`/// <reference path=".${name}" />`);
+    });
+    const filePath = path.join(process.cwd(), './lib/index.d.ts');
+    const contents = fs.readFileSync(filePath, 'utf8');
+    const updatedContents = `${lines.join('\n')}\n${contents}`;
+    fs.writeFileSync(filePath, updatedContents);
+}
+/** Copy the Shaders.d.ts file to the lib folder This is needed for proper frag,vert,wgsl support in the types */
+function copyShaders() {
+    const src = path.join(process.cwd(), './types');
+    const lib = path.join(process.cwd(), './lib');
+    fs.copyFileSync(`${src}/Shaders.d.ts`, `${lib}/Shaders.d.ts`);
+    // add this to the index.d.ts file
+    const filePath = path.join(process.cwd(), './lib/index.d.ts');
+    const contents = fs.readFileSync(filePath, 'utf8');
+    if (!contents.includes('/// <reference path="./Shaders.d.ts" />')) {
+        const updatedContents = `/// <reference path="./Shaders.d.ts" />\n${contents}`;
+        fs.writeFileSync(filePath, updatedContents);
+    }
+}
+addMixinReferencePaths();
+copyShaders();

package/dist/packages/pixijs/scripts/utils/autoGenerateUnsafeEvalFunctions.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=autoGenerateUnsafeEvalFunctions.d.ts.map

package/dist/packages/pixijs/scripts/utils/autoGenerateUnsafeEvalFunctions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"autoGenerateUnsafeEvalFunctions.d.ts","sourceRoot":"","sources":["../../../../../packages/pixijs/scripts/utils/autoGenerateUnsafeEvalFunctions.ts"],"names":[],"mappings":""}

package/dist/packages/pixijs/scripts/utils/autoGenerateUnsafeEvalFunctions.js

@@ -0,0 +1,99 @@
+import { writeFileSync } from 'fs-extra';
+import { UNIFORM_TO_ARRAY_SETTERS, UNIFORM_TO_SINGLE_SETTERS } from '../../src/rendering/renderers/gl/shader/utils/generateUniformsSyncTypes';
+import { uboSyncFunctionsSTD40, uboSyncFunctionsWGSL } from '../../src/rendering/renderers/shared/shader/utils/uboSyncFunctions';
+import { uniformParsers } from '../../src/rendering/renderers/shared/shader/utils/uniformParsers';
+/**
+ * this file auto generates the unsafe eval functions for uniforms and uniform buffers
+ * it is used to generate the files:
+ * - src/unsafe-eval/uniformSyncFunctions.ts
+ * - src/unsafe-eval/uniformBufferSyncFunctions.ts
+ *
+ * This exists so we only have to maintain the all these parsers in one place.
+ */
+const header = `
+/**
+ * This file is auto generated by scripts/utils/autoGenerateUnsafeEvalFunctions.ts
+ * Do not edit manually - or you will be sad.
+ */
+
+import type { UNIFORM_TYPES } from '../rendering/renderers/shared/shader/types';
+`;
+function autoGenerateUnsafeEvalFunctions() {
+    function convertToFunctionWithLocation(body) {
+        body = body.replace('location', `ud[name].location`);
+        return `function(name:string, cu:any, cv:any, v:any, ud:any, uv:any, gl:any):void
+        {
+            ${body}
+        }`;
+    }
+    function convertToFunction(body) {
+        return `(name:string, cu:any, cv:any, v:any, ud:any, uv:any, gl:any):void =>
+        {
+            ${body}
+        }`;
+    }
+    const out = [header];
+    // eslint-disable-next-line max-len
+    out.push(`export type UniformUploadFunction = (name: string, cu: any, cv: any, v: any, ud: any, uv: any, gl: any) => void;`);
+    out.push('export const uniformSingleParserFunctions:Record<UNIFORM_TYPES|string, UniformUploadFunction> = {');
+    for (const i in UNIFORM_TO_SINGLE_SETTERS) {
+        const fn = UNIFORM_TO_SINGLE_SETTERS[i];
+        out.push(`'${i}': ${convertToFunctionWithLocation(fn)},`);
+    }
+    out.push('};\n');
+    out.push('export const uniformArrayParserFunctions:Record<UNIFORM_TYPES|string, UniformUploadFunction> = {');
+    for (const i in UNIFORM_TO_ARRAY_SETTERS) {
+        const fn = UNIFORM_TO_ARRAY_SETTERS[i];
+        out.push(`'${i}': ${convertToFunctionWithLocation(fn)},`);
+    }
+    out.push('};\n');
+    // now add the uniform parsers..
+    out.push('export const uniformParserFunctions:UniformUploadFunction[] = [');
+    for (const i in uniformParsers) {
+        const fn = uniformParsers[i].uniform;
+        out.push(`${convertToFunction(fn)},`);
+    }
+    out.push('];');
+    const final = out.join('\n');
+    const path = 'src/unsafe-eval/uniformSyncFunctions.ts';
+    writeFileSync(path, final, 'utf8');
+}
+// uniform buffers!
+function autoGenerateUboUnsafeEvalFunctions() {
+    var _a;
+    const out = [header];
+    out.push(`export type UboUploadFunction = (name:string, data:Float32Array, offset:number, uv:any, v:any) => void;`);
+    function convertToFunction(body) {
+        return `(name:string, data:Float32Array, offset:number, uv:any, v:any):void =>
+        {
+            ${body}
+        }`;
+    }
+    // now add the uniform parsers..
+    out.push('export const uboParserFunctions:UboUploadFunction[] = [');
+    for (const i in uniformParsers) {
+        const fn = (_a = uniformParsers[i].uboWgsl) !== null && _a !== void 0 ? _a : uniformParsers[i].ubo;
+        out.push(`${convertToFunction(fn)},`);
+    }
+    out.push('];');
+    // and the basic uploads
+    // now add the uniform parsers..
+    out.push('export const uboSingleFunctionsWGSL:Record<UNIFORM_TYPES|string, UboUploadFunction> = {');
+    for (const i in uboSyncFunctionsWGSL) {
+        const fn = uboSyncFunctionsWGSL[i];
+        out.push(`'${i}': ${convertToFunction(fn)},`);
+    }
+    out.push('};');
+    // now add the uniform parsers..
+    out.push('export const uboSingleFunctionsSTD40:Record<UNIFORM_TYPES|string, UboUploadFunction> = {');
+    for (const i in uboSyncFunctionsSTD40) {
+        const fn = uboSyncFunctionsSTD40[i];
+        out.push(`'${i}': ${convertToFunction(fn)},`);
+    }
+    out.push('};');
+    const final = out.join('\n');
+    const path = 'src/unsafe-eval/uboSyncFunctions.ts';
+    writeFileSync(path, final, 'utf8');
+}
+autoGenerateUnsafeEvalFunctions();
+autoGenerateUboUnsafeEvalFunctions();

package/dist/packages/pixijs/scripts/utils/bump.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Ask the user to do a version bump.
+ * @param currentVersion - Current version to change from.
+ * @returns The next version.
+ */
+export declare const bump: (currentVersion: string) => Promise<string>;
+//# sourceMappingURL=bump.d.ts.map

package/dist/packages/pixijs/scripts/utils/bump.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bump.d.ts","sourceRoot":"","sources":["../../../../../packages/pixijs/scripts/utils/bump.ts"],"names":[],"mappings":"AAUA;;;;GAIG;AACH,eAAO,MAAM,IAAI,GAAU,gBAAgB,MAAM,KAAG,OAAO,CAAC,MAAM,CAkDjE,CAAC"}

package/dist/packages/pixijs/scripts/utils/bump.js

@@ -0,0 +1,56 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import inquirer from 'inquirer';
+import semver from 'semver';
+/**
+ * Ask the user to do a version bump.
+ * @param currentVersion - Current version to change from.
+ * @returns The next version.
+ */
+export const bump = (currentVersion) => __awaiter(void 0, void 0, void 0, function* () {
+    const { bump, custom, confirmed } = yield inquirer.prompt([{
+            name: 'bump',
+            type: 'list',
+            message: `Release version (currently v${currentVersion}):`,
+            choices: [
+                { value: 'prerelease', name: `Prerelease (v${semver.inc(currentVersion, 'prerelease')})` },
+                { value: 'patch', name: `Patch (v${semver.inc(currentVersion, 'patch')})` },
+                { value: 'minor', name: `Minor (v${semver.inc(currentVersion, 'minor')})` },
+                { value: 'major', name: `Major (v${semver.inc(currentVersion, 'major')})` },
+                { value: 'custom', name: `Custom version` },
+            ],
+        }, {
+            name: 'custom',
+            type: 'input',
+            message: 'What version? (e.g., 1.0.0)',
+            when: (answers) => answers.bump === 'custom',
+        }, {
+            name: 'confirmed',
+            type: 'confirm',
+            default: false,
+            message: ({ bump, custom }) => {
+                const nextVersion = bump === 'custom' ? custom : semver.inc(currentVersion, bump);
+                return `Are you sure you want to release v${nextVersion}?`;
+            },
+        }]);
+    if (!confirmed) {
+        throw new Error(`Version bump cancelled.`);
+    }
+    const nextVersion = bump === 'custom' ? custom : semver.inc(currentVersion, bump);
+    // Make sure the version is valid
+    if (nextVersion === null || semver.valid(nextVersion) === null) {
+        throw new Error(`Error: Invalid version: ${nextVersion}`);
+    }
+    // Make sure we are incrementing the version
+    if (semver.lte(nextVersion, currentVersion)) {
+        throw new Error(`Error: Next version (v${nextVersion}) is less than current version (v${currentVersion}).`);
+    }
+    return nextVersion;
+});

package/dist/packages/pixijs/scripts/utils/exports.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=exports.d.ts.map

package/dist/packages/pixijs/scripts/utils/exports.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exports.d.ts","sourceRoot":"","sources":["../../../../../packages/pixijs/scripts/utils/exports.ts"],"names":[],"mappings":""}

package/dist/packages/pixijs/scripts/utils/exports.js

@@ -0,0 +1,89 @@
+// need to be able to generate multiple index entry files
+// e.g. main, webworker, node, etc.
+import { readJSONSync, writeJSONSync } from 'fs-extra';
+// sub imports can be generated by finding `init` files? or should it just be a manual list?
+const subImports = [
+    ['./accessibility', './lib/accessibility'],
+    ['./advanced-blend-modes', './lib/advanced-blend-modes'],
+    ['./app', './lib/app'],
+    ['./dds', './lib/compressed-textures/dds'],
+    ['./ktx', './lib/compressed-textures/ktx'],
+    ['./ktx2', './lib/compressed-textures/ktx2'],
+    ['./basis', './lib/compressed-textures/basis'],
+    ['./events', './lib/events'],
+    ['./dom', './lib/dom'],
+    ['./filters', './lib/filters'],
+    ['./math-extras', './lib/math-extras'],
+    ['./sprite-tiling', './lib/scene/sprite-tiling'],
+    ['./text', './lib/scene/text'],
+    ['./text-bitmap', './lib/scene/text-bitmap'],
+    ['./text-html', './lib/scene/text-html'],
+    ['./graphics', './lib/scene/graphics'],
+    ['./mesh', './lib/scene/mesh'],
+    ['./prepare', './lib/prepare'],
+    ['./unsafe-eval', './lib/unsafe-eval'],
+    ['./sprite-nine-slice', './lib/scene/sprite-nine-slice'],
+    ['./particle-container', './lib/scene/particle-container'],
+];
+const exportFields = {
+    '.': {
+        import: {
+            types: './lib/index.d.ts',
+            default: './lib/index.mjs',
+        },
+        require: {
+            types: './lib/index.d.ts',
+            default: './lib/index.js',
+        },
+    },
+    './browser': {
+        import: {
+            default: './lib/environment-browser/browserAll.mjs',
+        },
+        require: {
+            default: './lib/environment-browser/browserAll.js',
+        },
+    },
+    './webworker': {
+        import: {
+            default: './lib/environment-webworker/webworkerAll.mjs',
+        },
+        require: {
+            default: './lib/environment-webworker/webworkerAll.js',
+        },
+    },
+    './gif': {
+        import: {
+            types: './lib/gif/init.d.ts',
+            default: './lib/gif/init.mjs',
+        },
+        require: {
+            types: './lib/gif/init.d.ts',
+            default: './lib/gif/init.js',
+        },
+    },
+};
+const sideEffects = [
+    './lib/environment-browser/browserAll.*',
+    './lib/environment-webworker/webworkerAll.*',
+    './lib/index.*',
+    './lib/rendering/init.*',
+    './lib/spritesheet/init.*',
+    './lib/rendering/renderers/shared/texture/utils/textureFrom.*',
+    './lib/gif/init.*',
+];
+for (const [name, path] of subImports) {
+    exportFields[name] = {
+        import: {
+            default: `${path}/init.mjs`,
+        },
+        require: {
+            default: `${path}/init.js`,
+        },
+    };
+    sideEffects.push(`${path}/init.*`);
+}
+const pkg = readJSONSync('./package.json');
+pkg.exports = exportFields;
+pkg.sideEffects = sideEffects;
+writeJSONSync('./package.json', pkg, { spaces: 2 });

package/dist/packages/pixijs/scripts/utils/spawn.d.ts

@@ -0,0 +1,9 @@
+import childProcess from 'child_process';
+/**
+ * Utility to do spawn but as a Promise
+ * @param command
+ * @param args
+ * @param options
+ */
+export declare const spawn: (command: string, args: string[], options?: childProcess.SpawnOptions) => Promise<void>;
+//# sourceMappingURL=spawn.d.ts.map

package/dist/packages/pixijs/scripts/utils/spawn.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spawn.d.ts","sourceRoot":"","sources":["../../../../../packages/pixijs/scripts/utils/spawn.ts"],"names":[],"mappings":"AAAA,OAAO,YAAY,MAAM,eAAe,CAAC;AAEzC;;;;;GAKG;AACH,eAAO,MAAM,KAAK,GAAI,SAAS,MAAM,EAAE,MAAM,MAAM,EAAE,EAAE,UAAS,YAAY,CAAC,YAAiB,kBAkBxF,CAAC"}

package/dist/packages/pixijs/scripts/utils/spawn.js

@@ -0,0 +1,25 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import childProcess from 'child_process';
+/**
+ * Utility to do spawn but as a Promise
+ * @param command
+ * @param args
+ * @param options
+ */
+export const spawn = (command, args, options = {}) => new Promise((resolve, reject) => {
+    const child = childProcess.spawn(command, args, Object.assign({ stdio: 'inherit', cwd: process.cwd(), shell: process.platform === 'win32' }, options));
+    child.on('close', (code) => __awaiter(void 0, void 0, void 0, function* () {
+        if (code === 0) {
+            resolve();
+        }
+    }));
+    child.on('error', reject);
+});