@azrico/webobject 1.5.58 → 1.5.61

package/dist/src/structs/MapableObject.js

@@ -0,0 +1,77 @@
+import { object_ensure, object_isEmpty } from "@azrico/object";
+import ObjectArray from "./ObjectArray";
+import { string_equals_ignorecase } from "@azrico/string";
+import { uid } from "@azrico/uid";
+import ObjectWithTemp from "./ObjectWithTemp";
+/**
+ * This object can be mapped and converted
+ */
+export class MapableObject extends ObjectWithTemp {
+    __uid;
+    __table_id;
+    __parent__table_id;
+    __row_number;
+    constructor() {
+        super();
+        this.__uid = uid.localuid();
+        this.__table_id = this.__uid;
+    }
+    getUID() {
+        return MapableObject.getUID(this);
+    }
+    /* -------------------------------------------------------------------------- */
+    static getUID(o) {
+        return o.__uid;
+    }
+    static mapto(maptoType, objectlist, is_readonly = true, ...p) {
+        if (objectlist === undefined) {
+            if (maptoType === undefined)
+                return [];
+            if (maptoType instanceof Object)
+                return [];
+            objectlist = maptoType;
+            maptoType = this;
+        }
+        if (object_isEmpty(objectlist))
+            return [];
+        if (objectlist instanceof ObjectArray)
+            objectlist = objectlist.getObjects();
+        if (!Array.isArray(objectlist)) {
+            objectlist = [objectlist];
+        }
+        return objectlist.map((r) => this.ensure(maptoType, r, is_readonly, ...p));
+    }
+    static ensure(maptoType, object, is_readonly, ...p) {
+        if (object === undefined) {
+            object = maptoType;
+            maptoType = this;
+        }
+        return object_ensure(maptoType, object, is_readonly, ...p);
+    }
+    /* -------------------------------------------------------------------------- */
+    static map_rowindex(objectlist) {
+        let index = 0;
+        return (objectlist?.map((r, i) => {
+            r.__row_number = ++index;
+            return r;
+        }) ?? []);
+    }
+    static map_tableid(objectlist) {
+        let index = 0;
+        return (objectlist?.map((r, i) => {
+            r.__table_id = r.__uid ?? String(++index);
+            return r;
+        }) ?? []);
+    }
+    static equals(a, b) {
+        console.warn("Dont use the default equals method !");
+        if (a == undefined || b == undefined)
+            return false;
+        if (typeof a === "object")
+            a = a.__uid;
+        if (typeof b === "object")
+            b = b.__uid;
+        return string_equals_ignorecase(a, b);
+    }
+}
+export default MapableObject;

package/dist/src/structs/MetaObject.d.ts

@@ -0,0 +1,15 @@
+import SimpleObject from "./SimpleObject";
+export declare class MetaObject extends SimpleObject {
+    id?: number;
+    key: string;
+    value: any;
+    constructor(initObject: string, value: string);
+    constructor(initObject: string, value: object);
+    constructor(initObject: object, value: undefined);
+    get_saveObject(): Promise<void>;
+    static get_saveObject(obj: MetaObject): Promise<void>;
+    Prepare(): Promise<boolean>;
+    get isNew(): boolean;
+    get isDeleted(): boolean;
+}
+export default MetaObject;

package/dist/src/structs/MetaObject.js

@@ -0,0 +1,35 @@
+import { object_isExactlyEmpty } from "@azrico/object";
+import SimpleObject from "./SimpleObject";
+export class MetaObject extends SimpleObject {
+    id;
+    key = "";
+    value;
+    constructor(initObject, value) {
+        super(false);
+        if (typeof initObject === "object") {
+            this.id = initObject.id;
+            this.key = initObject.key;
+            this.value = initObject.value;
+        }
+        else if (typeof initObject === "string") {
+            this.key = initObject;
+            this.value = value;
+        }
+        this.setOriginal();
+    }
+    async get_saveObject() {
+        return await MetaObject.get_saveObject(this);
+    }
+    static async get_saveObject(obj) { }
+    async Prepare() {
+        this.key = String(this.key);
+        return await Promise.resolve(true);
+    }
+    get isNew() {
+        return this.id == null || Number(this.id) <= 0;
+    }
+    get isDeleted() {
+        return object_isExactlyEmpty(this.value);
+    }
+}
+export default MetaObject;

package/dist/src/structs/ObjectArray.d.ts

@@ -0,0 +1,10 @@
+type wobjInput<T> = ObjectArray<any> | ObjectArray<any>[] | T | T[];
+export declare class ObjectArray<T> {
+    objArray: T[];
+    constructor(initObject?: wobjInput<T>, mapto_type?: any);
+    addObjects(initObject?: wobjInput<T>, mapto_type?: any): boolean;
+    setObjects(initObject?: wobjInput<T>, mapto_type?: any): void;
+    getObjects(): T[];
+    static flattenWebObjects<T>(inputData: wobjInput<T>): T[];
+}
+export default ObjectArray;

package/dist/src/structs/ObjectArray.js

@@ -0,0 +1,43 @@
+export class ObjectArray {
+    /* -------------------------------------------------------------------------- */
+    /*                                   Values                                   */
+    /* -------------------------------------------------------------------------- */
+    objArray = [];
+    /* -------------------------------------------------------------------------- */
+    /*                                    Base                                    */
+    /* -------------------------------------------------------------------------- */
+    constructor(initObject, mapto_type) {
+        this.setObjects(initObject, mapto_type);
+    }
+    addObjects(initObject, mapto_type) {
+        if (initObject == null)
+            return false;
+        let resultObjects = ObjectArray.flattenWebObjects(initObject);
+        if (mapto_type)
+            resultObjects = resultObjects.map((r) => r instanceof mapto_type ? r : new mapto_type(r));
+        resultObjects.map((s) => this.objArray.push(s));
+        return true;
+    }
+    setObjects(initObject, mapto_type) {
+        this.objArray = [];
+        this.addObjects(initObject, mapto_type);
+    }
+    getObjects() {
+        return this.objArray;
+    }
+    static flattenWebObjects(inputData) {
+        if (inputData instanceof ObjectArray) {
+            return ObjectArray.flattenWebObjects(inputData.objArray);
+        }
+        else if (Array.isArray(inputData)) {
+            let final_result = [];
+            inputData.map((ind) => {
+                ObjectArray.flattenWebObjects(ind).map((s) => final_result.push(s));
+            });
+            return final_result;
+        }
+        else
+            return [inputData];
+    }
+}
+export default ObjectArray;

package/dist/src/structs/ObjectManager.d.ts

@@ -0,0 +1,136 @@
+import { PropOf, WriteablePropOf } from "@azrico/types";
+import SimpleObject, { WithManager } from "./SimpleObject";
+import { saveResultType, sendChangesType } from "./SimpleObject";
+import { ClassType } from "@azrico/types";
+import RawObject from "./MapableObject";
+/**
+ * This class manages the events of an Simple Object
+ */
+export declare class ObjectManager<ObjType extends SimpleObject> extends RawObject {
+    __eventList: any;
+    __eventPrefix?: string;
+    __stopEvents?: boolean;
+    protected static readonly __object_type: () => typeof SimpleObject | ClassType<SimpleObject>;
+    protected __last_object_data: {
+        [key: string]: string;
+    };
+    protected __currentObject?: ObjType | null;
+    protected __options?: object;
+    __object_nullable: boolean;
+    constructor(defaultObject?: ObjType);
+    notifyChanged(type: string, key: PropOf<ObjType> | string, value?: any, subvalue?: string): Promise<false | any[] | undefined>;
+    /**
+     * Get the object this manager is managing
+     * @returns the object
+     */
+    get obj(): WithManager<ObjType> | undefined;
+    /**
+     * Get the object this manager is managing
+     * @returns the object
+     */
+    getObject(): WithManager<ObjType> | undefined;
+    /**
+     * Set the object this manager is managing
+     * @param toObj
+     * @returns
+     */
+    setObject(toObj: ObjType | undefined): boolean;
+    get d(): any;
+    get isChanged(): boolean;
+    get isDeleted(): boolean;
+    get isArchived(): boolean;
+    get isLocked(): boolean;
+    get canModify(): boolean;
+    get isNew(): boolean;
+    get isSaved(): boolean;
+    getSaveResult(): any | null;
+    getSaveResultType(): saveResultType | null;
+    setSaveResult(toObj: any, type: saveResultType): saveResultType | undefined;
+    apply_changes(): boolean;
+    get(key: PropOf<ObjType>, original?: boolean): import("@azrico/types").PropType<ObjType, any> | null;
+    useProperty(key: PropOf<ObjType>): Pick<this, any>;
+    /**
+     * set value
+     * @param key
+     * @param value
+     * @return true if changed , false otherwise
+     */
+    set(key: WriteablePropOf<ObjType>, value: any): Promise<boolean>;
+    /**
+     * set key of subObject
+     * @param key
+     * @param value
+     * @param subvalue
+     * @return true if changed , false otherwise
+     */
+    setSubValue(key: PropOf<ObjType>, objKey: string, subvalue: any): Promise<boolean>;
+    pushValue(key: PropOf<ObjType>, value: any): Promise<false | NonNullable<Awaited<ObjType[any]>>>;
+    setTemp(key: string, value: any, sendChanges?: sendChangesType): Promise<boolean>;
+    setObjectTemp(key: string, value: any, sendChanges?: sendChangesType): Promise<boolean>;
+    getObjectTemp(key: string): any;
+    getIndexOrID(): number | string;
+    getIndex(): number;
+    getID(): string;
+    event_run(eventName: string, ...params: any): Promise<any[] | undefined>;
+    event_use(name: string, runEvent: (...inputdata: any) => any, onlyOn?: any, runOnce?: boolean): any;
+    /**
+     * only useful for getter functions that dont rely on states
+     * @param name
+     * @param runEvent
+     * @param onlyOn
+     * @returns
+     */
+    event_use_getter(name: string, runEvent: (...inputdata: any) => any, onlyOn?: any): any;
+    event_remove(name: string, uname: string): boolean;
+    event_add(name: string, uname: string, runEvent: (...inputdata: any) => any, onlyOn?: any, runOnce?: boolean): Promise<void>;
+    events_start(): void;
+    events_stop(): void;
+    events_clear(): void;
+    clear_changes(): boolean;
+    clear_cache(): boolean;
+    static events_clear(obj: ObjectManager<any>): void;
+    /**
+     * Set an option to some value, if its already equal to the value it will be deleted instead
+     * @param key
+     * @param value
+     * @returns
+     */
+    toggleOption(key: string, value: any): Promise<void>;
+    getOption(key: string): any;
+    /**
+     * updates `__options` and runs the `event_run`
+     * @param key
+     * @param value
+     * @returns true if changed, false otherwise
+     */
+    setOption(key: string, value: any): Promise<boolean>;
+    /**
+     * use an option and detect its changes in real time. similar to React state
+     * @param key name of the option
+     * @returns value of the option
+     */
+    useOption(key: string): any;
+    /**
+     * Sets an option then does an action,
+     * after the action is run, updates the option again
+     * @param key
+     * @param value
+     * @param nextvalue
+     * @param action
+     */
+    holdOption(key: string, value: any, nextvalue: any, action: Function): Promise<void>;
+    /**
+     * @returns isChanged
+     */
+    useIsChanged(): any;
+    checkIsChanged(): Promise<void>;
+    addError(title?: string, message?: string, sendToRegister?: boolean | "auto"): any[] | undefined;
+    getErrors(): any[];
+    clearErrors(): boolean;
+    static addError(o?: ObjectManager<any>, title?: string, message?: string, sendToRegister?: boolean | "auto"): any[] | undefined;
+    static getErrors(o: ObjectManager<any>): any[];
+    static clearErrors(o: ObjectManager<any>): boolean;
+    getObjectType(): typeof SimpleObject;
+    static getObjectType(): typeof SimpleObject | ClassType<SimpleObject>;
+}
+export default ObjectManager;

package/dist/src/structs/ObjectManager.js

@@ -0,0 +1,332 @@
+import { EventManager } from "@azrico/event";
+import SimpleObject from "./SimpleObject";
+import { combine_if_not_blank } from "@azrico/string";
+import { gfunc } from "@azrico/global";
+import { fn_eval, object_equals_loose, } from "@azrico/object";
+import RawObject from "./MapableObject";
+/**
+ * This class manages the events of an Simple Object
+ */
+export class ObjectManager extends RawObject {
+    __eventList = {};
+    __eventPrefix;
+    __stopEvents;
+    static __object_type;
+    __last_object_data = {};
+    __currentObject;
+    __options;
+    //can the current object be set to null safely?
+    __object_nullable = false;
+    constructor(defaultObject) {
+        super();
+        this.setObject(defaultObject);
+    }
+    async notifyChanged(type, key, value, subvalue) {
+        const obj = this.getObject();
+        if (!obj)
+            return false;
+        if (value === undefined && type != "meta")
+            value = obj.get(key);
+        const typestr = (type ? `$${type}$` : "") + String(key);
+        return await this.event_run("on_change", typestr, value);
+    }
+    /* -------------------------------------------------------------------------- */
+    /**
+     * Get the object this manager is managing
+     * @returns the object
+     */
+    get obj() {
+        return this.__currentObject ?? undefined;
+    }
+    /**
+     * Get the object this manager is managing
+     * @returns the object
+     */
+    getObject() {
+        return this.__currentObject ?? undefined;
+    }
+    /**
+     * Set the object this manager is managing
+     * @param toObj
+     * @returns
+     */
+    setObject(toObj) {
+        this.__currentObject = toObj;
+        if (this.obj) {
+            this.obj.get_managerClass = () => this;
+            // this.obj.set_managerClass(this);
+        }
+        if (toObj == null && !this.__object_nullable) {
+            console.warn("setObject was used to set null. try to use empty objects instead of null");
+        }
+        return true;
+    }
+    /* -------------------------------------------------------------------------- */
+    /*                               Child functions                              */
+    /* -------------------------------------------------------------------------- */
+    get d() {
+        return this.obj?.d || {};
+    }
+    get isChanged() {
+        return this.obj != null && this.obj.isChanged;
+    }
+    get isDeleted() {
+        return this.obj == null || this.obj.isDeleted;
+    }
+    get isArchived() {
+        return this.obj == null || this.obj.isArchived;
+    }
+    get isLocked() {
+        return this.obj == null || this.obj.isLocked;
+    }
+    get canModify() {
+        return !this.obj?.canModify;
+    }
+    get isNew() {
+        return this.obj == null || this.obj.isNew;
+    }
+    get isSaved() {
+        return this.obj?.isSaved || false;
+    }
+    getSaveResult() {
+        return this.obj?.getSaveResult() || null;
+    }
+    getSaveResultType() {
+        return this.obj?.getSaveResultType() || null;
+    }
+    setSaveResult(toObj, type) {
+        return this.obj?.setSaveResult(toObj, type);
+    }
+    apply_changes() {
+        return this.obj?.apply_changes() || false;
+    }
+    get(key, original = false) {
+        const thisobj = this.obj;
+        if (thisobj == null || typeof thisobj.get != "function") {
+            if (!this.__object_nullable)
+                console.error("cant use get when object is not defined. maybe you have to use New() ?");
+            return null;
+        }
+        return thisobj.get(key, original);
+    }
+    useProperty(key) {
+        return EventManager.useProperty(this, key);
+    }
+    /**
+     * set value
+     * @param key
+     * @param value
+     * @return true if changed , false otherwise
+     */
+    async set(key, value) {
+        const thisobj = this.obj;
+        if (thisobj == null || typeof thisobj.set != "function") {
+            if (!this.__object_nullable)
+                console.error("cant use set when object is not defined. maybe you have to use New() ?");
+            return false;
+        }
+        return (await thisobj.set(key, value)) || false;
+    }
+    /**
+     * set key of subObject
+     * @param key
+     * @param value
+     * @param subvalue
+     * @return true if changed , false otherwise
+     */
+    async setSubValue(key, objKey, subvalue) {
+        return ((await this.obj?.setSubValue(key, objKey, subvalue)) ?? false);
+    }
+    //Push value on array
+    async pushValue(key, value) {
+        return (await this.obj?.pushValue(key, value)) ?? false;
+    }
+    //set temp value of object
+    async setTemp(key, value, sendChanges = false) {
+        await this.setObjectTemp(key, value, sendChanges);
+        return await super.setTemp(key, value);
+    }
+    //set temp value of object
+    async setObjectTemp(key, value, sendChanges = false) {
+        return (await this.obj?.setTemp(key, value, sendChanges)) ?? false;
+    }
+    //get temp value of object
+    getObjectTemp(key) {
+        return this.obj?.getTemp(key) ?? undefined;
+    }
+    /* -------------------------------------------------------------------------- */
+    getIndexOrID() {
+        return this.obj?.getIndexOrID() || -1;
+    }
+    getIndex() {
+        return this.obj?.getIndex() || -1;
+    }
+    getID() {
+        return this.obj?.getID() || "";
+    }
+    /* -------------------------------------------------------------------------- */
+    /*                                   Events                                   */
+    /* -------------------------------------------------------------------------- */
+    async event_run(eventName, ...params) {
+        if (this.__stopEvents === true)
+            return;
+        return await EventManager.run(this, eventName, ...params);
+    }
+    event_use(name, runEvent, onlyOn = null, runOnce = false) {
+        return EventManager.use(this, name, runEvent, onlyOn, runOnce);
+    }
+    /**
+     * only useful for getter functions that dont rely on states
+     * @param name
+     * @param runEvent
+     * @param onlyOn
+     * @returns
+     */
+    event_use_getter(name, runEvent, onlyOn = null) {
+        return EventManager.use_getter(this, name, runEvent, onlyOn);
+    }
+    event_remove(name, uname) {
+        return EventManager.remove(this, name, uname);
+    }
+    async event_add(name, uname, runEvent, onlyOn = null, runOnce = false) {
+        await EventManager.add(this, name, uname, runEvent, onlyOn, runOnce);
+    }
+    events_start() {
+        delete this.__stopEvents;
+    }
+    events_stop() {
+        this.__stopEvents = true;
+    }
+    events_clear() {
+        ObjectManager.events_clear(this);
+    }
+    clear_changes() {
+        return this.obj?.clear_changes() ?? false;
+    }
+    clear_cache() {
+        return this.obj?.clear_cache() ?? false;
+    }
+    static events_clear(obj) {
+        EventManager.removeAll(obj);
+    }
+    /* -------------------------------------------------------------------------- */
+    /*                                   Options                                  */
+    /* -------------------------------------------------------------------------- */
+    /**
+     * Set an option to some value, if its already equal to the value it will be deleted instead
+     * @param key
+     * @param value
+     * @returns
+     */
+    async toggleOption(key, value) {
+        var oldval = this.getOption(key);
+        if (object_equals_loose(oldval, value)) {
+            await this.setOption(key, null);
+        }
+        else
+            await this.setOption(key, value);
+    }
+    getOption(key) {
+        if (this.__options == null)
+            return undefined;
+        key = key.toLowerCase();
+        return this.__options[key];
+    }
+    /**
+     * updates `__options` and runs the `event_run`
+     * @param key
+     * @param value
+     * @returns true if changed, false otherwise
+     */
+    async setOption(key, value) {
+        if (this.__options == null)
+            this.__options = {};
+        key = key.toLowerCase();
+        const isChanged = this.__options[key] !== value;
+        if (value == null) {
+            delete this.__options[key];
+        }
+        else {
+            this.__options[key] = value;
+        }
+        await this.event_run("on_option_change", key, value);
+        return isChanged;
+    }
+    /**
+     * use an option and detect its changes in real time. similar to React state
+     * @param key name of the option
+     * @returns value of the option
+     */
+    useOption(key) {
+        return this.event_use_getter("on_option_change", () => this.getOption(key), [key]);
+    }
+    /**
+     * Sets an option then does an action,
+     * after the action is run, updates the option again
+     * @param key
+     * @param value
+     * @param nextvalue
+     * @param action
+     */
+    async holdOption(key, value, nextvalue, action) {
+        try {
+            this.setOption(key, value);
+            if (typeof action === "function")
+                await action();
+        }
+        finally {
+            this.setOption(key, nextvalue);
+        }
+    }
+    /* ------------------------------ useIsChanged; ----------------------------- */
+    /**
+     * @returns isChanged
+     */
+    useIsChanged() {
+        return this.useOption("ischanged");
+    }
+    async checkIsChanged() {
+        await this.setOption("ischanged", this.isChanged);
+    }
+    /* -------------------------------------------------------------------------- */
+    /*                                   Errors                                   */
+    /* -------------------------------------------------------------------------- */
+    addError(title, message, sendToRegister = "auto") {
+        return ObjectManager.addError(this, title, message, sendToRegister);
+    }
+    getErrors() {
+        return ObjectManager.getErrors(this);
+    }
+    clearErrors() {
+        return ObjectManager.clearErrors(this);
+    }
+    static addError(o, title, message, sendToRegister = "auto") {
+        if (o && o.obj) {
+            return SimpleObject.addError(o.obj, title, message, sendToRegister);
+        }
+        const errStr = combine_if_not_blank(title, " : ", message);
+        console.error("[REGISTER-ERROR]", errStr);
+        gfunc.run_action("add_error", {
+            title: title,
+            message: message,
+            type: "error",
+        });
+    }
+    static getErrors(o) {
+        const obj = o.obj;
+        return obj != null ? SimpleObject.getErrors(o.obj) : [];
+    }
+    static clearErrors(o) {
+        return SimpleObject.clearErrors(o.obj);
+    }
+    /* -------------------------------------------------------------------------- */
+    /*                              get __object_type                             */
+    /* -------------------------------------------------------------------------- */
+    getObjectType() {
+        return this.constructor["getObjectType"]();
+    }
+    static getObjectType() {
+        return fn_eval(this.__object_type);
+    }
+}
+export default ObjectManager;

package/dist/src/structs/ObjectWithTemp.d.ts

@@ -0,0 +1,16 @@
+/**
+ * This object supports temp values
+ */
+export declare class ObjectWithTemp {
+    #private;
+    protected __temp: any;
+    constructor();
+    getTemp: (key: string) => any;
+    setTemp(key: string, value: any): Promise<boolean>;
+    /**
+     * clear and discard all temp values
+     * @returns
+     */
+    clear_cache(): boolean;
+}
+export default ObjectWithTemp;