@mulsense/xnew 0.1.10 → 0.1.12

package/README.md

@@ -1,46 +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/@mulsense/xnew@0.1.x/dist/xnew.js"></script>
-```
-
-### Via CDN (ESM)
-Use the ES module version with an import map:
-```html
-<script type="importmap">
-{
-    "imports": {
-        "@mulsense/xnew": "https://unpkg.com/@mulsense/xnew@0.1.x/dist/xnew.mjs"
-    }
-}
-</script>
-
-<script type="module">
-import xnew from '@mulsense/xnew';
-
-// Your code here
-</script>
-```
-
-### Via npm
-Install `xnew` using npm:
-```bash
-npm install @mulsense/xnew@0.1.x
-```
-
-Then import it in your JavaScript file:
-```js
-import xnew from '@mulsense/xnew';
-```
+# 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/@mulsense/xnew@0.1.x/dist/xnew.js"></script>
+```
+
+### Via CDN (ESM)
+Use the ES module version with an import map:
+```html
+<script type="importmap">
+{
+    "imports": {
+        "@mulsense/xnew": "https://unpkg.com/@mulsense/xnew@0.1.x/dist/xnew.mjs"
+    }
+}
+</script>
+
+<script type="module">
+import xnew from '@mulsense/xnew';
+
+// Your code here
+</script>
+```
+
+### Via npm
+Install `xnew` using npm:
+```bash
+npm install @mulsense/xnew@0.1.x
+```
+
+Then import it in your JavaScript file:
+```js
+import xnew from '@mulsense/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,43 @@
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory(require('@mulsense/xnew'), require('matter-js')) :
+    typeof define === 'function' && define.amd ? define(['@mulsense/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.context('xmatter.object', 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);
+        Matter.Composite.add(parent, object);
+        self.on('finalize', () => {
+            Matter.Composite.remove(parent, object);
+        });
+    }
+
+    return xmatter;
+
+}));

package/dist/addons/xmatter.mjs

@@ -0,0 +1,38 @@
+import xnew from '@mulsense/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.context('xmatter.object', 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);
+    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,106 @@
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory(require('@mulsense/xnew'), require('pixi.js')) :
+    typeof define === 'function' && define.amd ? define(['@mulsense/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;
+        },
+        capture() {
+            var _a, _b;
+            const render = (_a = xnew.context('xpixi.root')) === null || _a === void 0 ? void 0 : _a.renderer;
+            const scene = (_b = xnew.context('xpixi.root')) === null || _b === void 0 ? void 0 : _b.scene;
+            const canvas = render.extract.canvas(scene);
+            return canvas.toDataURL('image/png', 1.0);
+        }
+    };
+    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);
+        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,82 @@
+import xnew from '@mulsense/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;
+    },
+    capture() {
+        var _a, _b;
+        const render = (_a = xnew.context('xpixi.root')) === null || _a === void 0 ? void 0 : _a.renderer;
+        const scene = (_b = xnew.context('xpixi.root')) === null || _b === void 0 ? void 0 : _b.scene;
+        const canvas = render.extract.canvas(scene);
+        return canvas.toDataURL('image/png', 1.0);
+    }
+};
+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);
+    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;
+    connect(type: any, object: any): any;
+    readonly world: any;
+};
+export default _default;

package/dist/addons/xrapier2d.js

@@ -0,0 +1,69 @@
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory(require('@mulsense/xnew'), require('@dimforge/rapier2d-compat')) :
+    typeof define === 'function' && define.amd ? define(['@mulsense/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 });
+        },
+        connect(type, object) {
+            xnew.extend(Connect, { type, 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();
+            }
+        });
+    }
+    let count = 0;
+    function Connect(self, { type, object }) {
+        const root = xnew.context('xrapier2d.root');
+        let temp = count++;
+        console.log(temp, type, object);
+        // 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 (type === 'rigidBody') {
+                    console.log('Removing RigidBody');
+                    root.world.removeRigidBody(object);
+                }
+                // Check if object is a Collider
+                else if (type === 'collider') {
+                    console.log('Removing Collider');
+                    root.world.removeCollider(object);
+                }
+                // Check if object is an ImpulseJoint
+                else if (type === 'impulseJoint') {
+                    console.log('Removing ImpulseJoint');
+                    root.world.removeImpulseJoint(object);
+                }
+            }
+            catch (e) {
+                // Object may have already been removed
+            }
+        });
+    }
+
+    return xrapier2d;
+
+}));

package/dist/addons/xrapier2d.mjs

@@ -0,0 +1,64 @@
+import xnew from '@mulsense/xnew';
+import RAPIER from '@dimforge/rapier2d-compat';
+
+var xrapier2d = {
+    initialize({ gravity = { x: 0.0, y: 9.81 }, timestep = null } = {}) {
+        xnew.extend(Root, { gravity, timestep });
+    },
+    connect(type, object) {
+        xnew.extend(Connect, { type, 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();
+        }
+    });
+}
+let count = 0;
+function Connect(self, { type, object }) {
+    const root = xnew.context('xrapier2d.root');
+    let temp = count++;
+    console.log(temp, type, object);
+    // 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 (type === 'rigidBody') {
+                console.log('Removing RigidBody');
+                root.world.removeRigidBody(object);
+            }
+            // Check if object is a Collider
+            else if (type === 'collider') {
+                console.log('Removing Collider');
+                root.world.removeCollider(object);
+            }
+            // Check if object is an ImpulseJoint
+            else if (type === 'impulseJoint') {
+                console.log('Removing ImpulseJoint');
+                root.world.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('@mulsense/xnew'), require('three')) :
+    typeof define === 'function' && define.amd ? define(['@mulsense/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.context('xthree.object', 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 '@mulsense/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.context('xthree.object', 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 };