vasille 3.2.0 → 3.2.1

package/lib/models/array-model.js

@@ -0,0 +1,152 @@
+import { Listener } from "./listener.js";
+/**
+ * Model based on Array class
+ * @extends Array
+ * @implements IModel
+ */
+export class ArrayModel extends Array {
+    /**
+     * @param data {Array} input data
+     */
+    constructor(data) {
+        super();
+        this.passive = false;
+        this.listener = new Listener();
+        if (data instanceof Array) {
+            for (let i = 0; i < data.length; i++) {
+                super.push(data[i]);
+            }
+        }
+    }
+    /* Array members */
+    /**
+     * Calls Array.fill and notify about changes
+     * @param value {*} value to fill with
+     * @param start {?number} begin index
+     * @param end {?number} end index
+     */
+    fill(value, start, end) {
+        this.passive = true;
+        /* istanbul ignore else */
+        if (!start) {
+            start = 0;
+        }
+        /* istanbul ignore else */
+        if (!end) {
+            end = this.length;
+        }
+        for (let i = start; i < end; i++) {
+            this.listener.emitRemoved(this[i], this[i]);
+            this[i] = value;
+            this.listener.emitAdded(value, value);
+        }
+        this.passive = false;
+        return this;
+    }
+    /**
+     * Calls Array.pop and notify about changes
+     * @return {*} removed value
+     */
+    pop() {
+        this.passive = true;
+        const v = super.pop();
+        /* istanbul ignore else */
+        if (v !== undefined) {
+            this.listener.emitRemoved(v, v);
+        }
+        this.passive = false;
+        return v;
+    }
+    /**
+     * Calls Array.push and notify about changes
+     * @param items {...*} values to push
+     * @return {number} new length of array
+     */
+    push(...items) {
+        this.passive = true;
+        items.forEach(item => {
+            this.listener.emitAdded(item, item);
+            super.push(item);
+        });
+        this.passive = false;
+        return this.length;
+    }
+    /**
+     * Calls Array.shift and notify about changed
+     * @return {*} the shifted value
+     */
+    shift() {
+        this.passive = true;
+        const v = super.shift();
+        /* istanbul ignore else */
+        if (v !== undefined) {
+            this.listener.emitRemoved(v, v);
+        }
+        this.passive = false;
+        return v;
+    }
+    /**
+     * Calls Array.splice and notify about changed
+     * @param start {number} start index
+     * @param deleteCount {?number} delete count
+     * @param items {...*}
+     * @return {ArrayModel} a pointer to this
+     */
+    splice(start, deleteCount, ...items) {
+        this.passive = true;
+        start = Math.min(start, this.length);
+        deleteCount = typeof deleteCount === "number" ? deleteCount : this.length - start;
+        const before = this[start + deleteCount];
+        for (let i = 0; i < deleteCount; i++) {
+            const index = start + deleteCount - i - 1;
+            /* istanbul ignore else */
+            if (this[index] !== undefined) {
+                this.listener.emitRemoved(this[index], this[index]);
+            }
+        }
+        for (let i = 0; i < items.length; i++) {
+            this.listener.emitAdded(before, items[i]);
+        }
+        this.passive = false;
+        return new ArrayModel(super.splice(start, deleteCount, ...items));
+    }
+    /**
+     * Calls Array.unshift and notify about changed
+     * @param items {...*} values to insert
+     * @return {number} the length after prepend
+     */
+    unshift(...items) {
+        this.passive = true;
+        for (let i = 0; i < items.length; i++) {
+            this.listener.emitAdded(this[i], items[i]);
+        }
+        const r = super.unshift(...items);
+        this.passive = false;
+        return r;
+    }
+    replace(at, with_) {
+        this.passive = true;
+        this.listener.emitAdded(this[at], with_);
+        this.listener.emitRemoved(this[at], this[at]);
+        this[at] = with_;
+        this.passive = false;
+        return this;
+    }
+    destroy() {
+        this.splice(0);
+    }
+}
+export function proxyArrayModel(arr) {
+    return new Proxy(arr, {
+        set(target, p, newValue, receiver) {
+            if (!arr.passive && typeof p === "string") {
+                const index = parseInt(p);
+                if (Number.isFinite(index)) {
+                    arr.replace(index, newValue);
+                    return true;
+                }
+            }
+            return Reflect.set(target, p, newValue, receiver);
+        },
+    });
+}

package/lib/models/listener.js

@@ -0,0 +1,66 @@
+/**
+ * Represent a listener for a model
+ * @class Listener
+ */
+export class Listener {
+    constructor() {
+        /**
+         * Functions to run on adding new items
+         * @type Set
+         */
+        this.onAdded = new Set();
+        /**
+         * Functions to run on item removing
+         * @type Set
+         */
+        this.onRemoved = new Set();
+    }
+    /**
+     * Emits added event to listeners
+     * @param index {*} index of value
+     * @param value {*} value of added item
+     */
+    emitAdded(index, value) {
+        this.onAdded.forEach(handler => {
+            handler(index, value);
+        });
+    }
+    /**
+     * Emits removed event to listeners
+     * @param index {*} index of removed value
+     * @param value {*} value of removed item
+     */
+    emitRemoved(index, value) {
+        this.onRemoved.forEach(handler => {
+            handler(index, value);
+        });
+    }
+    /**
+     * Adds a handler to added event
+     * @param handler {function} function to run on event emitting
+     */
+    onAdd(handler) {
+        this.onAdded.add(handler);
+    }
+    /**
+     * Adds a handler to removed event
+     * @param handler {function} function to run on event emitting
+     */
+    onRemove(handler) {
+        this.onRemoved.add(handler);
+    }
+    /**
+     * Removes an handler from added event
+     * @param handler {function} handler to remove
+     */
+    offAdd(handler) {
+        this.onAdded.delete(handler);
+    }
+    /**
+     * Removes an handler form removed event
+     * @param handler {function} handler to remove
+     */
+    offRemove(handler) {
+        this.onRemoved.delete(handler);
+    }
+}

package/lib/models/map-model.js

@@ -0,0 +1,60 @@
+import { Listener } from "./listener.js";
+/**
+ * A Map based memory
+ * @class MapModel
+ * @extends Map
+ * @implements IModel
+ */
+export class MapModel extends Map {
+    /**
+     * Constructs a map model
+     * @param map {[*, *][]} input data
+     */
+    constructor(map) {
+        super();
+        this.listener = new Listener();
+        map?.forEach(([key, value]) => {
+            super.set(key, value);
+        });
+    }
+    /**
+     * Calls Map.clear and notify about changes
+     */
+    clear() {
+        this.forEach((value, key) => {
+            this.listener.emitRemoved(key, value);
+        });
+        super.clear();
+    }
+    /**
+     * Calls Map.delete and notify abut changes
+     * @param key {*} key
+     * @return {boolean} true if removed something, otherwise false
+     */
+    delete(key) {
+        const tmp = super.get(key);
+        /* istanbul ignore else */
+        if (tmp) {
+            this.listener.emitRemoved(key, tmp);
+        }
+        return super.delete(key);
+    }
+    /**
+     * Calls Map.set and notify abut changes
+     * @param key {*} key
+     * @param value {*} value
+     * @return {MapModel} a pointer to this
+     */
+    set(key, value) {
+        const tmp = super.get(key);
+        if (tmp) {
+            this.listener.emitRemoved(key, tmp);
+        }
+        super.set(key, value);
+        this.listener.emitAdded(key, value);
+        return this;
+    }
+    destroy() {
+        this.clear();
+    }
+}

package/lib/models/model.js

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

package/lib/models/set-model.js

@@ -0,0 +1,56 @@
+import { Listener } from "./listener.js";
+/**
+ * A Set based model
+ * @class SetModel
+ * @extends Set
+ * @implements IModel
+ */
+export class SetModel extends Set {
+    /**
+     * Constructs a set model based on a set
+     * @param set {Set} input data
+     */
+    constructor(set) {
+        super();
+        this.listener = new Listener();
+        set?.forEach(item => {
+            super.add(item);
+        });
+    }
+    /**
+     * Calls Set.add and notify abut changes
+     * @param value {*} value
+     * @return {this} a pointer to this
+     */
+    add(value) {
+        /* istanbul ignore else */
+        if (!super.has(value)) {
+            this.listener.emitAdded(value, value);
+            super.add(value);
+        }
+        return this;
+    }
+    /**
+     * Calls Set.clear and notify abut changes
+     */
+    clear() {
+        this.forEach(item => {
+            this.listener.emitRemoved(item, item);
+        });
+        super.clear();
+    }
+    /**
+     * Calls Set.delete and notify abut changes
+     * @param value {*}
+     * @return {boolean} true if a value was deleted, otherwise false
+     */
+    delete(value) {
+        if (super.has(value)) {
+            this.listener.emitRemoved(value, value);
+        }
+        return super.delete(value);
+    }
+    destroy() {
+        this.clear();
+    }
+}

package/package.json

@@ -3,7 +3,7 @@
   "description": "The first Developer eXperience Orientated front-end framework (core library).",
   "main": "lib/index.js",
   "types": "types/index.d.ts",
-  "version": "3.2.0",
+  "version": "3.2.1",
   "exports": {
     ".": {
       "types": "./types/index.d.ts",

package/types/models/array-model.d.ts

@@ -0,0 +1,55 @@
+import { Listener } from "./listener.js";
+import { ListenableModel } from "./model.js";
+/**
+ * Model based on Array class
+ * @extends Array
+ * @implements IModel
+ */
+export declare class ArrayModel<T> extends Array<T> implements ListenableModel<T, T> {
+    listener: Listener<T, T>;
+    passive: boolean;
+    /**
+     * @param data {Array} input data
+     */
+    constructor(data?: Array<T> | number);
+    /**
+     * Calls Array.fill and notify about changes
+     * @param value {*} value to fill with
+     * @param start {?number} begin index
+     * @param end {?number} end index
+     */
+    fill(value: T, start?: number, end?: number): this;
+    /**
+     * Calls Array.pop and notify about changes
+     * @return {*} removed value
+     */
+    pop(): T | undefined;
+    /**
+     * Calls Array.push and notify about changes
+     * @param items {...*} values to push
+     * @return {number} new length of array
+     */
+    push(...items: Array<T>): number;
+    /**
+     * Calls Array.shift and notify about changed
+     * @return {*} the shifted value
+     */
+    shift(): T | undefined;
+    /**
+     * Calls Array.splice and notify about changed
+     * @param start {number} start index
+     * @param deleteCount {?number} delete count
+     * @param items {...*}
+     * @return {ArrayModel} a pointer to this
+     */
+    splice(start: number, deleteCount?: number, ...items: Array<T>): ArrayModel<T>;
+    /**
+     * Calls Array.unshift and notify about changed
+     * @param items {...*} values to insert
+     * @return {number} the length after prepend
+     */
+    unshift(...items: Array<T>): number;
+    replace(at: number, with_: T): this;
+    destroy(): void;
+}
+export declare function proxyArrayModel<T>(arr: ArrayModel<T>): ArrayModel<T>;

package/types/models/listener.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Represent a listener for a model
+ * @class Listener
+ */
+export declare class Listener<ValueT, IndexT = string | number> {
+    /**
+     * Functions to run on adding new items
+     * @type Set
+     */
+    private readonly onAdded;
+    /**
+     * Functions to run on item removing
+     * @type Set
+     */
+    private readonly onRemoved;
+    /**
+     * Emits added event to listeners
+     * @param index {*} index of value
+     * @param value {*} value of added item
+     */
+    emitAdded(index: IndexT, value: ValueT): void;
+    /**
+     * Emits removed event to listeners
+     * @param index {*} index of removed value
+     * @param value {*} value of removed item
+     */
+    emitRemoved(index: IndexT, value: ValueT): void;
+    /**
+     * Adds a handler to added event
+     * @param handler {function} function to run on event emitting
+     */
+    onAdd(handler: (index: IndexT, value: ValueT) => void): void;
+    /**
+     * Adds a handler to removed event
+     * @param handler {function} function to run on event emitting
+     */
+    onRemove(handler: (index: IndexT, value: ValueT) => void): void;
+    /**
+     * Removes an handler from added event
+     * @param handler {function} handler to remove
+     */
+    offAdd(handler: (index: IndexT, value: ValueT) => void): void;
+    /**
+     * Removes an handler form removed event
+     * @param handler {function} handler to remove
+     */
+    offRemove(handler: (index: IndexT, value: ValueT) => void): void;
+}

package/types/models/map-model.d.ts

@@ -0,0 +1,34 @@
+import { Listener } from "./listener.js";
+import { ListenableModel } from "./model.js";
+/**
+ * A Map based memory
+ * @class MapModel
+ * @extends Map
+ * @implements IModel
+ */
+export declare class MapModel<K, T> extends Map<K, T> implements ListenableModel<K, T> {
+    listener: Listener<T, K>;
+    /**
+     * Constructs a map model
+     * @param map {[*, *][]} input data
+     */
+    constructor(map?: [K, T][]);
+    /**
+     * Calls Map.clear and notify about changes
+     */
+    clear(): void;
+    /**
+     * Calls Map.delete and notify abut changes
+     * @param key {*} key
+     * @return {boolean} true if removed something, otherwise false
+     */
+    delete(key: K): boolean;
+    /**
+     * Calls Map.set and notify abut changes
+     * @param key {*} key
+     * @param value {*} value
+     * @return {MapModel} a pointer to this
+     */
+    set(key: K, value: T): this;
+    destroy(): void;
+}

package/types/models/model.d.ts

@@ -0,0 +1,14 @@
+import { IDestroyable } from "../core/destroyable.js";
+import { Listener } from "./listener.js";
+/**
+ * @interface IModel
+ */
+export interface IModel extends IDestroyable {
+}
+export interface ListenableModel<K, T> extends IModel {
+    /**
+     * The listener of model
+     * @type Listener
+     */
+    listener: Listener<T, K>;
+}

package/types/models/set-model.d.ts

@@ -0,0 +1,33 @@
+import { Listener } from "./listener.js";
+import { ListenableModel } from "./model.js";
+/**
+ * A Set based model
+ * @class SetModel
+ * @extends Set
+ * @implements IModel
+ */
+export declare class SetModel<T> extends Set<T> implements ListenableModel<T, T> {
+    listener: Listener<T, T>;
+    /**
+     * Constructs a set model based on a set
+     * @param set {Set} input data
+     */
+    constructor(set?: T[]);
+    /**
+     * Calls Set.add and notify abut changes
+     * @param value {*} value
+     * @return {this} a pointer to this
+     */
+    add(value: T): this;
+    /**
+     * Calls Set.clear and notify abut changes
+     */
+    clear(): void;
+    /**
+     * Calls Set.delete and notify abut changes
+     * @param value {*}
+     * @return {boolean} true if a value was deleted, otherwise false
+     */
+    delete(value: T): boolean;
+    destroy(): void;
+}