@mulsense/xnew 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 - 2025 mulsense
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,46 @@
+# xnew
+`xnew` is a JavaScript / TypeScript library for component-oriented programming,
+providing a flexible architecture well-suited for applications with dynamic scenes and games.
+
+[**Visit the xnew website**](https://mulsense.github.io/xnew)
+
+<div>
+    <img src="website/static/img/introduction.svg" width="500" alt="xnew introduction" />
+</div>
+
+## Setup
+
+### Via CDN
+Include the following script in your HTML file:
+```html
+<script src="https://unpkg.com/xnew@5.0.x/dist/xnew.js"></script>
+```
+
+### Via CDN (ESM)
+Use the ES module version with an import map:
+```html
+<script type="importmap">
+{
+    "imports": {
+        "xnew": "https://unpkg.com/xnew@5.0.x/dist/xnew.mjs"
+    }
+}
+</script>
+
+<script type="module">
+import xnew from 'xnew';
+
+// Your code here
+</script>
+```
+
+### Via npm
+Install `xnew` using npm:
+```bash
+npm install xnew@5.0.x
+```
+
+Then import it in your JavaScript file:
+```js
+import xnew from 'xnew';
+```

package/dist/addons/xmatter.d.ts

@@ -0,0 +1,6 @@
+declare const _default: {
+    initialize({ engine }?: any): void;
+    nest(object: any): any;
+    readonly engine: any;
+};
+export default _default;

package/dist/addons/xmatter.js

@@ -0,0 +1,45 @@
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory(require('xnew'), require('matter-js')) :
+    typeof define === 'function' && define.amd ? define(['xnew', 'matter-js'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.xmatter = factory(global.xnew, global.Matter));
+})(this, (function (xnew, Matter) { 'use strict';
+
+    var xmatter = {
+        initialize({ engine = null } = {}) {
+            xnew.extend(Root, { engine });
+        },
+        nest(object) {
+            xnew.extend(Nest, object);
+            return object;
+        },
+        get engine() {
+            var _a;
+            return (_a = xnew.context('xmatter.root')) === null || _a === void 0 ? void 0 : _a.engine;
+        },
+    };
+    function Root(self, { engine }) {
+        const root = {};
+        xnew.context('xmatter.root', root);
+        root.isActive = true;
+        root.engine = engine !== null && engine !== void 0 ? engine : Matter.Engine.create();
+        xnew.extend(Nest, root.engine.world);
+        self.on('update', () => {
+            if (root.isActive) {
+                Matter.Engine.update(root.engine);
+            }
+        });
+    }
+    function Nest(self, object) {
+        const parent = xnew.context('xmatter.object');
+        xnew.context('xmatter.object', object);
+        if (parent) {
+            Matter.Composite.add(parent, object);
+            self.on('finalize', () => {
+                Matter.Composite.remove(parent, object);
+            });
+        }
+    }
+
+    return xmatter;
+
+}));

package/dist/addons/xmatter.mjs

@@ -0,0 +1,40 @@
+import xnew from 'xnew';
+import Matter from 'matter-js';
+
+var xmatter = {
+    initialize({ engine = null } = {}) {
+        xnew.extend(Root, { engine });
+    },
+    nest(object) {
+        xnew.extend(Nest, object);
+        return object;
+    },
+    get engine() {
+        var _a;
+        return (_a = xnew.context('xmatter.root')) === null || _a === void 0 ? void 0 : _a.engine;
+    },
+};
+function Root(self, { engine }) {
+    const root = {};
+    xnew.context('xmatter.root', root);
+    root.isActive = true;
+    root.engine = engine !== null && engine !== void 0 ? engine : Matter.Engine.create();
+    xnew.extend(Nest, root.engine.world);
+    self.on('update', () => {
+        if (root.isActive) {
+            Matter.Engine.update(root.engine);
+        }
+    });
+}
+function Nest(self, object) {
+    const parent = xnew.context('xmatter.object');
+    xnew.context('xmatter.object', object);
+    if (parent) {
+        Matter.Composite.add(parent, object);
+        self.on('finalize', () => {
+            Matter.Composite.remove(parent, object);
+        });
+    }
+}
+
+export { xmatter as default };

package/dist/addons/xpixi.d.ts

@@ -0,0 +1,10 @@
+import * as PIXI from 'pixi.js';
+declare const _default: {
+    initialize({ renderer, canvas }?: any): void;
+    nest(object: any): any;
+    sync(canvas: any): PIXI.Texture<PIXI.TextureSource<any>>;
+    readonly renderer: any;
+    readonly scene: any;
+    readonly canvas: any;
+};
+export default _default;

package/dist/addons/xpixi.js

@@ -0,0 +1,101 @@
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory(require('xnew'), require('pixi.js')) :
+    typeof define === 'function' && define.amd ? define(['xnew', 'pixi.js'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.xpixi = factory(global.xnew, global.PIXI));
+})(this, (function (xnew, PIXI) { 'use strict';
+
+    function _interopNamespaceDefault(e) {
+        var n = Object.create(null);
+        if (e) {
+            Object.keys(e).forEach(function (k) {
+                if (k !== 'default') {
+                    var d = Object.getOwnPropertyDescriptor(e, k);
+                    Object.defineProperty(n, k, d.get ? d : {
+                        enumerable: true,
+                        get: function () { return e[k]; }
+                    });
+                }
+            });
+        }
+        n.default = e;
+        return Object.freeze(n);
+    }
+
+    var PIXI__namespace = /*#__PURE__*/_interopNamespaceDefault(PIXI);
+
+    var xpixi = {
+        initialize({ renderer = null, canvas = null } = {}) {
+            xnew.extend(Root, { renderer, canvas });
+        },
+        nest(object) {
+            xnew.extend(Nest, object);
+            return object;
+        },
+        sync(canvas) {
+            const texture = PIXI__namespace.Texture.from(canvas);
+            xnew(PreUpdate, () => {
+                texture.source.update();
+            });
+            return texture;
+        },
+        get renderer() {
+            var _a;
+            return (_a = xnew.context('xpixi.root')) === null || _a === void 0 ? void 0 : _a.renderer;
+        },
+        get scene() {
+            var _a;
+            return (_a = xnew.context('xpixi.root')) === null || _a === void 0 ? void 0 : _a.scene;
+        },
+        get canvas() {
+            var _a;
+            return (_a = xnew.context('xpixi.root')) === null || _a === void 0 ? void 0 : _a.canvas;
+        }
+    };
+    function Root(self, { canvas }) {
+        const root = {};
+        xnew.context('xpixi.root', root);
+        root.canvas = canvas;
+        const renderer = PIXI__namespace.autoDetectRenderer({
+            width: canvas.width, height: canvas.height, view: canvas,
+            antialias: true, backgroundAlpha: 0,
+        });
+        root.renderer = null;
+        if (renderer instanceof Promise) {
+            xnew.promise(renderer).then((renderer) => root.renderer = renderer);
+        }
+        else {
+            root.renderer = renderer;
+        }
+        root.updates = [];
+        root.scene = new PIXI__namespace.Container();
+        xnew.context('xpixi.object', root.scene);
+        self.on('update', () => {
+            root.updates.forEach((update) => {
+                update();
+            });
+            if (root.renderer && root.scene) {
+                root.renderer.render(root.scene);
+            }
+        });
+    }
+    function Nest(self, object) {
+        const parent = xnew.context('xpixi.object');
+        xnew.context('xpixi.object', object);
+        if (parent) {
+            parent.addChild(object);
+            self.on('finalize', () => {
+                parent.removeChild(object);
+            });
+        }
+    }
+    function PreUpdate(self, callback) {
+        const root = xnew.context('xpixi.root');
+        root.updates.push(callback);
+        self.on('finalize', () => {
+            root.updates = root.updates.filter((update) => update !== callback);
+        });
+    }
+
+    return xpixi;
+
+}));

package/dist/addons/xpixi.mjs

@@ -0,0 +1,77 @@
+import xnew from 'xnew';
+import * as PIXI from 'pixi.js';
+
+var xpixi = {
+    initialize({ renderer = null, canvas = null } = {}) {
+        xnew.extend(Root, { renderer, canvas });
+    },
+    nest(object) {
+        xnew.extend(Nest, object);
+        return object;
+    },
+    sync(canvas) {
+        const texture = PIXI.Texture.from(canvas);
+        xnew(PreUpdate, () => {
+            texture.source.update();
+        });
+        return texture;
+    },
+    get renderer() {
+        var _a;
+        return (_a = xnew.context('xpixi.root')) === null || _a === void 0 ? void 0 : _a.renderer;
+    },
+    get scene() {
+        var _a;
+        return (_a = xnew.context('xpixi.root')) === null || _a === void 0 ? void 0 : _a.scene;
+    },
+    get canvas() {
+        var _a;
+        return (_a = xnew.context('xpixi.root')) === null || _a === void 0 ? void 0 : _a.canvas;
+    }
+};
+function Root(self, { canvas }) {
+    const root = {};
+    xnew.context('xpixi.root', root);
+    root.canvas = canvas;
+    const renderer = PIXI.autoDetectRenderer({
+        width: canvas.width, height: canvas.height, view: canvas,
+        antialias: true, backgroundAlpha: 0,
+    });
+    root.renderer = null;
+    if (renderer instanceof Promise) {
+        xnew.promise(renderer).then((renderer) => root.renderer = renderer);
+    }
+    else {
+        root.renderer = renderer;
+    }
+    root.updates = [];
+    root.scene = new PIXI.Container();
+    xnew.context('xpixi.object', root.scene);
+    self.on('update', () => {
+        root.updates.forEach((update) => {
+            update();
+        });
+        if (root.renderer && root.scene) {
+            root.renderer.render(root.scene);
+        }
+    });
+}
+function Nest(self, object) {
+    const parent = xnew.context('xpixi.object');
+    xnew.context('xpixi.object', object);
+    if (parent) {
+        parent.addChild(object);
+        self.on('finalize', () => {
+            parent.removeChild(object);
+        });
+    }
+}
+function PreUpdate(self, callback) {
+    const root = xnew.context('xpixi.root');
+    root.updates.push(callback);
+    self.on('finalize', () => {
+        root.updates = root.updates.filter((update) => update !== callback);
+    });
+}
+
+export { xpixi as default };

package/dist/addons/xrapier2d.d.ts

@@ -0,0 +1,6 @@
+declare const _default: {
+    initialize({ gravity, timestep }?: any): void;
+    nest(object: any): any;
+    readonly world: any;
+};
+export default _default;

package/dist/addons/xrapier2d.js

@@ -0,0 +1,66 @@
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory(require('xnew'), require('@dimforge/rapier2d-compat')) :
+    typeof define === 'function' && define.amd ? define(['xnew', '@dimforge/rapier2d-compat'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.xrapier2d = factory(global.xnew, global.RAPIER));
+})(this, (function (xnew, RAPIER) { 'use strict';
+
+    var xrapier2d = {
+        initialize({ gravity = { x: 0.0, y: 9.81 }, timestep = null } = {}) {
+            xnew.extend(Root, { gravity, timestep });
+        },
+        nest(object) {
+            xnew.extend(Nest, object);
+            return object;
+        },
+        get world() {
+            var _a;
+            return (_a = xnew.context('xrapier2d.root')) === null || _a === void 0 ? void 0 : _a.world;
+        },
+    };
+    function Root(self, { gravity, timestep }) {
+        const root = {};
+        xnew.context('xrapier2d.root', root);
+        xnew.promise(RAPIER.init()).then(() => {
+            root.world = new RAPIER.World(gravity);
+            if (timestep !== null) {
+                root.world.timestep = timestep;
+            }
+            xnew.extend(Nest, root.world);
+        });
+        self.on('update', () => {
+            if (root.world) {
+                root.world.step();
+            }
+        });
+    }
+    function Nest(self, object) {
+        const parent = xnew.context('xrapier2d.object');
+        xnew.context('xrapier2d.object', object);
+        if (parent) {
+            // Rapier2D objects (RigidBody, Collider, etc.) are already added to the world
+            // when created, so we only need to handle removal on finalize
+            self.on('finalize', () => {
+                try {
+                    // Check if object is a RigidBody
+                    if (object.translation && typeof object.translation === 'function') {
+                        parent.removeRigidBody(object);
+                    }
+                    // Check if object is a Collider
+                    else if (object.shape && typeof object.shape === 'function') {
+                        parent.removeCollider(object);
+                    }
+                    // Check if object is an ImpulseJoint
+                    else if (object.impulse !== undefined) {
+                        parent.removeImpulseJoint(object);
+                    }
+                }
+                catch (e) {
+                    // Object may have already been removed
+                }
+            });
+        }
+    }
+
+    return xrapier2d;
+
+}));

package/dist/addons/xrapier2d.mjs

@@ -0,0 +1,61 @@
+import xnew from 'xnew';
+import RAPIER from '@dimforge/rapier2d-compat';
+
+var xrapier2d = {
+    initialize({ gravity = { x: 0.0, y: 9.81 }, timestep = null } = {}) {
+        xnew.extend(Root, { gravity, timestep });
+    },
+    nest(object) {
+        xnew.extend(Nest, object);
+        return object;
+    },
+    get world() {
+        var _a;
+        return (_a = xnew.context('xrapier2d.root')) === null || _a === void 0 ? void 0 : _a.world;
+    },
+};
+function Root(self, { gravity, timestep }) {
+    const root = {};
+    xnew.context('xrapier2d.root', root);
+    xnew.promise(RAPIER.init()).then(() => {
+        root.world = new RAPIER.World(gravity);
+        if (timestep !== null) {
+            root.world.timestep = timestep;
+        }
+        xnew.extend(Nest, root.world);
+    });
+    self.on('update', () => {
+        if (root.world) {
+            root.world.step();
+        }
+    });
+}
+function Nest(self, object) {
+    const parent = xnew.context('xrapier2d.object');
+    xnew.context('xrapier2d.object', object);
+    if (parent) {
+        // Rapier2D objects (RigidBody, Collider, etc.) are already added to the world
+        // when created, so we only need to handle removal on finalize
+        self.on('finalize', () => {
+            try {
+                // Check if object is a RigidBody
+                if (object.translation && typeof object.translation === 'function') {
+                    parent.removeRigidBody(object);
+                }
+                // Check if object is a Collider
+                else if (object.shape && typeof object.shape === 'function') {
+                    parent.removeCollider(object);
+                }
+                // Check if object is an ImpulseJoint
+                else if (object.impulse !== undefined) {
+                    parent.removeImpulseJoint(object);
+                }
+            }
+            catch (e) {
+                // Object may have already been removed
+            }
+        });
+    }
+}
+
+export { xrapier2d as default };

package/dist/addons/xthree.d.ts

@@ -0,0 +1,9 @@
+declare const _default: {
+    initialize({ renderer, canvas, camera }?: any): void;
+    nest(object: any): any;
+    readonly renderer: any;
+    readonly camera: any;
+    readonly scene: any;
+    readonly canvas: any;
+};
+export default _default;

package/dist/addons/xthree.js

@@ -0,0 +1,77 @@
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory(require('xnew'), require('three')) :
+    typeof define === 'function' && define.amd ? define(['xnew', 'three'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.xthree = factory(global.xnew, global.THREE));
+})(this, (function (xnew, THREE) { 'use strict';
+
+    function _interopNamespaceDefault(e) {
+        var n = Object.create(null);
+        if (e) {
+            Object.keys(e).forEach(function (k) {
+                if (k !== 'default') {
+                    var d = Object.getOwnPropertyDescriptor(e, k);
+                    Object.defineProperty(n, k, d.get ? d : {
+                        enumerable: true,
+                        get: function () { return e[k]; }
+                    });
+                }
+            });
+        }
+        n.default = e;
+        return Object.freeze(n);
+    }
+
+    var THREE__namespace = /*#__PURE__*/_interopNamespaceDefault(THREE);
+
+    var xthree = {
+        initialize({ renderer = null, canvas = null, camera = null } = {}) {
+            xnew.extend(Root, { renderer, canvas, camera });
+        },
+        nest(object) {
+            xnew.extend(Nest, object);
+            return object;
+        },
+        get renderer() {
+            var _a;
+            return (_a = xnew.context('xthree.root')) === null || _a === void 0 ? void 0 : _a.renderer;
+        },
+        get camera() {
+            var _a;
+            return (_a = xnew.context('xthree.root')) === null || _a === void 0 ? void 0 : _a.camera;
+        },
+        get scene() {
+            var _a;
+            return (_a = xnew.context('xthree.root')) === null || _a === void 0 ? void 0 : _a.scene;
+        },
+        get canvas() {
+            var _a;
+            return (_a = xnew.context('xthree.root')) === null || _a === void 0 ? void 0 : _a.canvas;
+        }
+    };
+    function Root(self, { canvas, camera }) {
+        const root = {};
+        xnew.context('xthree.root', root);
+        root.canvas = canvas;
+        root.renderer = new THREE__namespace.WebGLRenderer({ canvas, alpha: true });
+        root.renderer.setClearColor(0x000000, 0);
+        root.camera = camera !== null && camera !== void 0 ? camera : new THREE__namespace.PerspectiveCamera(45, root.renderer.domElement.width / root.renderer.domElement.height);
+        root.scene = new THREE__namespace.Scene();
+        xnew.extend(Nest, root.scene);
+        self.on('update', () => {
+            root.renderer.render(root.scene, root.camera);
+        });
+    }
+    function Nest(self, object) {
+        const parent = xnew.context('xthree.object');
+        xnew.context('xthree.object', object);
+        if (parent) {
+            parent === null || parent === void 0 ? void 0 : parent.add(object);
+            self.on('finalize', () => {
+                parent === null || parent === void 0 ? void 0 : parent.remove(object);
+            });
+        }
+    }
+
+    return xthree;
+
+}));

package/dist/addons/xthree.mjs

@@ -0,0 +1,53 @@
+import xnew from 'xnew';
+import * as THREE from 'three';
+
+var xthree = {
+    initialize({ renderer = null, canvas = null, camera = null } = {}) {
+        xnew.extend(Root, { renderer, canvas, camera });
+    },
+    nest(object) {
+        xnew.extend(Nest, object);
+        return object;
+    },
+    get renderer() {
+        var _a;
+        return (_a = xnew.context('xthree.root')) === null || _a === void 0 ? void 0 : _a.renderer;
+    },
+    get camera() {
+        var _a;
+        return (_a = xnew.context('xthree.root')) === null || _a === void 0 ? void 0 : _a.camera;
+    },
+    get scene() {
+        var _a;
+        return (_a = xnew.context('xthree.root')) === null || _a === void 0 ? void 0 : _a.scene;
+    },
+    get canvas() {
+        var _a;
+        return (_a = xnew.context('xthree.root')) === null || _a === void 0 ? void 0 : _a.canvas;
+    }
+};
+function Root(self, { canvas, camera }) {
+    const root = {};
+    xnew.context('xthree.root', root);
+    root.canvas = canvas;
+    root.renderer = new THREE.WebGLRenderer({ canvas, alpha: true });
+    root.renderer.setClearColor(0x000000, 0);
+    root.camera = camera !== null && camera !== void 0 ? camera : new THREE.PerspectiveCamera(45, root.renderer.domElement.width / root.renderer.domElement.height);
+    root.scene = new THREE.Scene();
+    xnew.extend(Nest, root.scene);
+    self.on('update', () => {
+        root.renderer.render(root.scene, root.camera);
+    });
+}
+function Nest(self, object) {
+    const parent = xnew.context('xthree.object');
+    xnew.context('xthree.object', object);
+    if (parent) {
+        parent === null || parent === void 0 ? void 0 : parent.add(object);
+        self.on('finalize', () => {
+            parent === null || parent === void 0 ? void 0 : parent.remove(object);
+        });
+    }
+}
+
+export { xthree as default };

package/dist/types/audio/audio.d.ts

@@ -0,0 +1,13 @@
+export type AudioNodeMap = {
+    [key: string]: AudioNode & {
+        [key: string]: any;
+    };
+};
+export declare class Audio {
+    static context: AudioContext | null;
+    static master: GainNode | null;
+    static initialize(): void;
+    static connect(params: {
+        [key: string]: any[];
+    }): AudioNodeMap;
+}

package/dist/types/audio/loader.d.ts

@@ -0,0 +1 @@
+export {};