@mulsense/xnew 0.1.0 → 0.1.2

package/README.md

@@ -13,7 +13,7 @@ providing a flexible architecture well-suited for applications with dynamic scen
 ### Via CDN
 Include the following script in your HTML file:
 ```html
-<script src="https://unpkg.com/xnew@5.0.x/dist/xnew.js"></script>
+<script src="https://unpkg.com/@mulsense/xnew@0.1.x/dist/xnew.js"></script>
 ```
 
 ### Via CDN (ESM)
@@ -22,13 +22,13 @@ Use the ES module version with an import map:
 <script type="importmap">
 {
     "imports": {
-        "xnew": "https://unpkg.com/xnew@5.0.x/dist/xnew.mjs"
+        "@mulsense/xnew": "https://unpkg.com/@mulsense/xnew@0.1.x/dist/xnew.mjs"
     }
 }
 </script>
 
 <script type="module">
-import xnew from 'xnew';
+import xnew from '@mulsense/xnew';
 
 // Your code here
 </script>
@@ -37,10 +37,10 @@ import xnew from 'xnew';
 ### Via npm
 Install `xnew` using npm:
 ```bash
-npm install xnew@5.0.x
+npm install @mulsense/xnew@0.1.x
 ```
 
 Then import it in your JavaScript file:
 ```js
-import xnew from 'xnew';
+import xnew from '@mulsense/xnew';
 ```

package/dist/addons/xmatter.js

@@ -1,6 +1,6 @@
 (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) :
+    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';
 

package/dist/addons/xmatter.mjs

@@ -1,4 +1,4 @@
-import xnew from 'xnew';
+import xnew from '@mulsense/xnew';
 import Matter from 'matter-js';
 
 var xmatter = {

package/dist/addons/xpixi.js

@@ -1,6 +1,6 @@
 (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) :
+    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';
 

package/dist/addons/xpixi.mjs

@@ -1,4 +1,4 @@
-import xnew from 'xnew';
+import xnew from '@mulsense/xnew';
 import * as PIXI from 'pixi.js';
 
 var xpixi = {

package/dist/addons/xrapier2d.js

@@ -1,6 +1,6 @@
 (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) :
+    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';
 

package/dist/addons/xrapier2d.mjs

@@ -1,4 +1,4 @@
-import xnew from 'xnew';
+import xnew from '@mulsense/xnew';
 import RAPIER from '@dimforge/rapier2d-compat';
 
 var xrapier2d = {

package/dist/addons/xthree.js

@@ -1,6 +1,6 @@
 (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) :
+    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';
 
@@ -56,7 +56,7 @@
         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);
+        xnew.context('xthree.object', root.scene);
         self.on('update', () => {
             root.renderer.render(root.scene, root.camera);
         });

package/dist/addons/xthree.mjs

@@ -1,4 +1,4 @@
-import xnew from 'xnew';
+import xnew from '@mulsense/xnew';
 import * as THREE from 'three';
 
 var xthree = {
@@ -34,7 +34,7 @@ function Root(self, { canvas, camera }) {
     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);
+    xnew.context('xthree.object', root.scene);
     self.on('update', () => {
         root.renderer.render(root.scene, root.camera);
     });

package/dist/types/core/map.d.ts

@@ -1,34 +1,21 @@
-declare class MapEx<Key, Value> {
-    protected map: Map<Key, Value>;
-    get size(): number;
-    forEach(callback: (value: Value, key: Key, map: Map<Key, Value>) => any): void;
-    clear(): void;
-}
-export declare class MapSet<Key, Value> extends MapEx<Key, Set<Value>> {
-    has(key: Key, value?: Value): boolean;
-    get(key: Key): Set<Value> | undefined;
-    keys(): IterableIterator<Key>;
+export declare class MapSet<Key, Value> extends Map<Key, Set<Value>> {
+    has(key: Key): boolean;
+    has(key: Key, value: Value): boolean;
     add(key: Key, value: Value): MapSet<Key, Value>;
-    delete(key: Key, value?: Value): boolean;
+    keys(): IterableIterator<Key>;
+    keys(key: Key): IterableIterator<Value>;
+    delete(key: Key): boolean;
+    delete(key: Key, value: Value): boolean;
 }
-export declare class MapMap<Key1, Key2, Value> extends MapEx<Key1, Map<Key2, Value>> {
-    has(key1: Key1, key2?: Key2): boolean;
-    set(key1: Key1, key2: Key2, value: Value): MapMap<Key1, Key2, Value>;
+export declare class MapMap<Key1, Key2, Value> extends Map<Key1, Map<Key2, Value>> {
+    has(key1: Key1): boolean;
+    has(key1: Key1, key2: Key2): boolean;
+    set(key1: Key1, value: Map<Key2, Value>): this;
+    set(key1: Key1, key2: Key2, value: Value): this;
     get(key1: Key1): Map<Key2, Value> | undefined;
     get(key1: Key1, key2: Key2): Value | undefined;
     keys(): IterableIterator<Key1>;
     keys(key1: Key1): IterableIterator<Key2>;
-    delete(key1: Key1, key2?: Key2): boolean;
-}
-export declare class MapMapMap<Key1, Key2, Key3, Value> extends MapEx<Key1, MapMap<Key2, Key3, Value>> {
-    has(key1: Key1, key2?: Key2, key3?: Key3): boolean;
-    set(key1: Key1, key2: Key2, key3: Key3, value: Value): MapMapMap<Key1, Key2, Key3, Value>;
-    get(key1: Key1): MapMap<Key2, Key3, Value> | undefined;
-    get(key1: Key1, key2: Key2): Map<Key3, Value> | undefined;
-    get(key1: Key1, key2: Key2, key3: Key3): Value | undefined;
-    keys(): IterableIterator<Key1>;
-    keys(key1: Key1): IterableIterator<Key2>;
-    keys(key1: Key1, key2: Key2): IterableIterator<Key3>;
-    delete(key1: Key1, key2?: Key2, key3?: Key3): boolean;
+    delete(key1: Key1): boolean;
+    delete(key1: Key1, key2: Key2): boolean;
 }
-export {};

package/dist/types/core/unit.d.ts

@@ -1,6 +1,5 @@
-import { MapSet, MapMapMap } from './map';
-declare const LIFECYCLE_EVENTS: readonly ["start", "update", "stop", "finalize"];
-type LifecycleEvent = typeof LIFECYCLE_EVENTS[number];
+import { MapSet, MapMap } from './map';
+export type UnitElement = HTMLElement | SVGElement;
 interface Context {
     stack: Context | null;
     key: string;
@@ -9,88 +8,77 @@ interface Context {
 interface Snapshot {
     unit: Unit | null;
     context: Context | null;
-    element: HTMLElement | SVGElement | null;
+    element: UnitElement | null;
 }
 interface Capture {
     checker: (unit: Unit) => boolean;
     execute: (unit: Unit) => any;
 }
 interface UnitInternal {
-    root: Unit;
     parent: Unit | null;
     children: Unit[];
     target: Object | null;
     props?: Object;
+    baseElement: UnitElement;
+    baseContext: Context | null;
+    baseComponent: Function;
+    currentElement: UnitElement;
     nextNest: {
-        element: HTMLElement | SVGElement;
+        element: UnitElement;
         position: InsertPosition;
     };
-    baseElement: HTMLElement | SVGElement;
-    currentElement: HTMLElement | SVGElement;
-    baseContext: Context | null;
-    baseComponent: Function | null;
-    components: Function[];
+    components: Set<Function>;
+    listeners: MapMap<string, Function, [UnitElement, Function]>;
+    sublisteners: MapMap<string, Function, [UnitElement | Window | Document, Function]>;
     captures: Capture[];
     state: string;
     tostart: boolean;
-    upcount: number;
-    resolved: boolean;
     defines: Record<string, any>;
-    system: Record<LifecycleEvent, Function[]>;
+    system: Record<string, Function[]>;
 }
 export declare class Unit {
     [key: string]: any;
     _: UnitInternal;
     static roots: Unit[];
     constructor(target: Object | null, component?: Function | string, props?: Object);
-    get element(): HTMLElement | SVGElement;
+    get element(): UnitElement;
     start(): void;
     stop(): void;
     finalize(): void;
     reboot(): void;
-    get components(): Function[];
-    on(type: string, listener: Function, options?: boolean | AddEventListenerOptions): Unit;
-    off(type?: string, listener?: Function): Unit;
-    emit(type: string, ...args: any[]): void;
-    static initialize(unit: Unit): void;
+    static initialize(unit: Unit, nextNest: {
+        element: UnitElement;
+        position: InsertPosition;
+    }): void;
     static finalize(unit: Unit): void;
-    static nest(unit: Unit, tag: string): HTMLElement | SVGElement | null;
+    static nest(unit: Unit, tag: string): UnitElement | null;
     static extend(unit: Unit, component: Function, props?: Object): void;
     static start(unit: Unit, time: number): void;
     static stop(unit: Unit): void;
     static update(unit: Unit, time: number): void;
     static ticker(time: number): void;
     static reset(): void;
+    static componentUnits: MapSet<Function, Unit>;
+    get components(): Set<Function>;
+    static find(component: Function): Unit[];
+    static typeUnits: MapSet<string, Unit>;
+    on(type: string, listener: Function, options?: boolean | AddEventListenerOptions): void;
+    off(type?: string, listener?: Function): void;
+    emit(type: string, ...args: any[]): void;
+    static subon(unit: any, target: UnitElement | Window | Document, type: string, listener: Function, options?: boolean | AddEventListenerOptions): void;
+    static suboff(unit: any, target: UnitElement | Window | Document | null, type?: string, listener?: Function): void;
 }
 export declare class UnitScope {
     static current: Unit | null;
     static contexts: Map<Unit | null, Context>;
     static initialize(unit: Unit | null, context: Context | null): void;
     static finalize(unit: Unit): void;
-    static set(unit: Unit, context: Context): void;
-    static get(unit: Unit | null): Context | null;
+    static wrap(listener: Function): (...args: any[]) => any;
     static execute(snapshot: Snapshot | null, func: Function, ...args: any[]): any;
     static snapshot(unit?: Unit | null): Snapshot | null;
     static stack(unit: Unit, key: string, value: any): void;
     static trace(unit: Unit, key: string): any;
 }
-export declare class UnitComponent {
-    static components: MapSet<Unit, Function>;
-    static units: MapSet<Function, Unit>;
-    static finalize(unit: Unit): void;
-    static add(unit: Unit, component: Function): void;
-    static find(component: Function): Unit[];
-}
-export declare class UnitEvent {
-    static units: MapSet<string, Unit>;
-    static listeners: MapMapMap<Unit, string, Function, [HTMLElement | SVGElement, (...args: any[]) => void]>;
-    static on(unit: Unit, type: string, listener: Function, options?: boolean | AddEventListenerOptions): void;
-    static off(unit: Unit, type?: string, listener?: Function): void;
-    static emit(unit: Unit, type: string, ...args: any[]): void;
-    static sublisteners: MapMapMap<Unit | null, string, Function, [HTMLElement | SVGElement | Window | Document, (...args: any[]) => void]>;
-    static subon(unit: Unit | null, target: HTMLElement | SVGElement | Window | Document, type: string, listener: Function, options?: boolean | AddEventListenerOptions): void;
-    static suboff(unit: Unit | null, target: HTMLElement | SVGElement | Window | Document | null, type?: string, listener?: Function): void;
-}
 export declare class UnitPromise {
     private promise;
     constructor(executor: (resolve: (value: any) => void, reject: (reason?: any) => void) => void);

package/dist/xnew.d.ts

@@ -1,7 +1,28 @@
 declare function ResizeEvent(self: any): void;
 
-declare const LIFECYCLE_EVENTS: readonly ["start", "update", "stop", "finalize"];
-type LifecycleEvent = typeof LIFECYCLE_EVENTS[number];
+declare class MapSet<Key, Value> extends Map<Key, Set<Value>> {
+    has(key: Key): boolean;
+    has(key: Key, value: Value): boolean;
+    add(key: Key, value: Value): MapSet<Key, Value>;
+    keys(): IterableIterator<Key>;
+    keys(key: Key): IterableIterator<Value>;
+    delete(key: Key): boolean;
+    delete(key: Key, value: Value): boolean;
+}
+declare class MapMap<Key1, Key2, Value> extends Map<Key1, Map<Key2, Value>> {
+    has(key1: Key1): boolean;
+    has(key1: Key1, key2: Key2): boolean;
+    set(key1: Key1, value: Map<Key2, Value>): this;
+    set(key1: Key1, key2: Key2, value: Value): this;
+    get(key1: Key1): Map<Key2, Value> | undefined;
+    get(key1: Key1, key2: Key2): Value | undefined;
+    keys(): IterableIterator<Key1>;
+    keys(key1: Key1): IterableIterator<Key2>;
+    delete(key1: Key1): boolean;
+    delete(key1: Key1, key2: Key2): boolean;
+}
+
+type UnitElement = HTMLElement | SVGElement;
 interface Context {
     stack: Context | null;
     key: string;
@@ -12,51 +33,58 @@ interface Capture {
     execute: (unit: Unit) => any;
 }
 interface UnitInternal {
-    root: Unit;
     parent: Unit | null;
     children: Unit[];
     target: Object | null;
     props?: Object;
+    baseElement: UnitElement;
+    baseContext: Context | null;
+    baseComponent: Function;
+    currentElement: UnitElement;
     nextNest: {
-        element: HTMLElement | SVGElement;
+        element: UnitElement;
         position: InsertPosition;
     };
-    baseElement: HTMLElement | SVGElement;
-    currentElement: HTMLElement | SVGElement;
-    baseContext: Context | null;
-    baseComponent: Function | null;
-    components: Function[];
+    components: Set<Function>;
+    listeners: MapMap<string, Function, [UnitElement, Function]>;
+    sublisteners: MapMap<string, Function, [UnitElement | Window | Document, Function]>;
     captures: Capture[];
     state: string;
     tostart: boolean;
-    upcount: number;
-    resolved: boolean;
     defines: Record<string, any>;
-    system: Record<LifecycleEvent, Function[]>;
+    system: Record<string, Function[]>;
 }
 declare class Unit {
     [key: string]: any;
     _: UnitInternal;
     static roots: Unit[];
     constructor(target: Object | null, component?: Function | string, props?: Object);
-    get element(): HTMLElement | SVGElement;
+    get element(): UnitElement;
     start(): void;
     stop(): void;
     finalize(): void;
     reboot(): void;
-    get components(): Function[];
-    on(type: string, listener: Function, options?: boolean | AddEventListenerOptions): Unit;
-    off(type?: string, listener?: Function): Unit;
-    emit(type: string, ...args: any[]): void;
-    static initialize(unit: Unit): void;
+    static initialize(unit: Unit, nextNest: {
+        element: UnitElement;
+        position: InsertPosition;
+    }): void;
     static finalize(unit: Unit): void;
-    static nest(unit: Unit, tag: string): HTMLElement | SVGElement | null;
+    static nest(unit: Unit, tag: string): UnitElement | null;
     static extend(unit: Unit, component: Function, props?: Object): void;
     static start(unit: Unit, time: number): void;
     static stop(unit: Unit): void;
     static update(unit: Unit, time: number): void;
     static ticker(time: number): void;
     static reset(): void;
+    static componentUnits: MapSet<Function, Unit>;
+    get components(): Set<Function>;
+    static find(component: Function): Unit[];
+    static typeUnits: MapSet<string, Unit>;
+    on(type: string, listener: Function, options?: boolean | AddEventListenerOptions): void;
+    off(type?: string, listener?: Function): void;
+    emit(type: string, ...args: any[]): void;
+    static subon(unit: any, target: UnitElement | Window | Document, type: string, listener: Function, options?: boolean | AddEventListenerOptions): void;
+    static suboff(unit: any, target: UnitElement | Window | Document | null, type?: string, listener?: Function): void;
 }
 
 interface xnewtype$1 {