@leyyo/common 1.0.4 → 1.0.6

package/dist/to/common-to.js

@@ -0,0 +1,868 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommonTo = void 0;
+const leyyo_1 = require("../leyyo");
+const internal_1 = require("../internal");
+const primitive_1 = require("./primitive");
+const real_value_1 = require("./real-value");
+const key_value_1 = require("./key-value");
+const weak_true_1 = require("./weak-true");
+const weak_false_1 = require("./weak-false");
+const list_1 = require("./list");
+// noinspection JSUnusedGlobalSymbols
+class CommonTo {
+    constructor() {
+        // region properties
+        this._EMPTY = [null, undefined];
+        this._EXPECTED_ANY = ['string', 'boolean', 'bigint', 'object', 'number', 'array'];
+        this._EXPECTED_ARRAY = ['array', 'Set'];
+        this._EXPECTED_BOOL = ['boolean', 'string', 'number'];
+        this._EXPECTED_DATE = ['string', 'number', 'date', 'moment'];
+        this._EXPECTED_ENUM = ['string', 'number'];
+        this._EXPECTED_NUMBER = ['string', 'number', 'bigint'];
+        this._EXPECTED_STRING = ['boolean', 'string', 'number'];
+        this._EXPECTED_OBJECT = ['object', 'Map'];
+        // endregion types
+    }
+    // endregion properties
+    // region private
+    _enumInMap(value, map) {
+        // regular, in values
+        if (Object.values(map).includes(value)) {
+            return value;
+        }
+        // ir-regular, in keys
+        if (Object.keys(map).includes(value)) {
+            return map[value];
+        }
+        if (typeof value === 'string') {
+            // regular, in lower-case
+            let str = value.toLowerCase();
+            let v = this._enumInMap(str, map);
+            if (!this._EMPTY.includes(v)) {
+                return v;
+            }
+            // regular, in upper-case
+            str = str.toUpperCase();
+            v = this._enumInMap(str, map);
+            if (!this._EMPTY.includes(v)) {
+                return v;
+            }
+            if (/^[0-9]+$/.test(value)) {
+                try {
+                    return this._enumInMap(parseInt(value, 10), map);
+                }
+                catch (e) {
+                }
+            }
+            return undefined;
+        }
+        return undefined;
+    }
+    _enumInArray(value, arr) {
+        // regular, in values
+        if (arr.includes(value)) {
+            return value;
+        }
+        if (typeof value === 'string') {
+            // regular, in lower-case
+            let str = value.toLowerCase();
+            let v = this._enumInArray(str, arr);
+            if (!this._EMPTY.includes(v)) {
+                return v;
+            }
+            // regular, in upper-case
+            str = str.toUpperCase();
+            v = this._enumInArray(str, arr);
+            if (!this._EMPTY.includes(v)) {
+                return v;
+            }
+            if (/^[0-9]+$/.test(value)) {
+                try {
+                    return this._enumInArray(parseInt(value, 10), arr);
+                }
+                catch (e) {
+                }
+            }
+            return undefined;
+        }
+        return undefined;
+    }
+    // noinspection JSMethodCanBeStatic
+    _enumInAlteration(value, alt) {
+        // ir-regular, in keys
+        if (Object.keys(alt).includes(value)) {
+            return alt[value];
+        }
+        if (typeof value === 'string') {
+            // regular, in lower-case
+            let str = value.toLowerCase();
+            let v = this._enumInAlteration(str, alt);
+            if (!this._EMPTY.includes(v)) {
+                return v;
+            }
+            // regular, in upper-case
+            str = str.toUpperCase();
+            v = this._enumInAlteration(str, alt);
+            if (!this._EMPTY.includes(v)) {
+                return v;
+            }
+            if (/^[0-9]+$/.test(value)) {
+                try {
+                    return this._enumInAlteration(parseInt(value, 10), alt);
+                }
+                catch (e) {
+                }
+            }
+            return undefined;
+        }
+        return undefined;
+    }
+    // endregion private
+    // region secure
+    $init(leyyo) {
+        this.is = leyyo.is;
+        this.dev = leyyo.dev;
+        this.wrapper = leyyo.wrapper;
+        leyyo.$secure.$lazyRun(() => {
+            const enumMap = {
+                Primitive: primitive_1.PrimitiveItems,
+                RealValue: real_value_1.RealValueItems,
+                KeyValue: key_value_1.KeyValueItems,
+                WeakTrue: weak_true_1.WeakTrueItems,
+                WeakFalse: weak_false_1.WeakFalseItems,
+            };
+            for (const [name, value] of Object.entries(enumMap)) {
+                leyyo.fqn.register(name, value, 'enum', internal_1.FQN_PCK);
+                leyyo.hook.queueForCallback(leyyo_1.LeyyoCommonHook.enumPendingRegister, value);
+            }
+        }).$lazyRun(() => {
+            leyyo.fqn.register(null, CommonTo, 'class', internal_1.FQN_PCK);
+            leyyo.fqn.register(null, list_1.List, 'class', internal_1.FQN_PCK);
+        });
+    }
+    get $back() {
+        return this;
+    }
+    get $secure() {
+        return this;
+    }
+    $runOpt(opt) {
+        if (typeof opt === 'function') {
+            try {
+                return opt();
+            }
+            catch (e) {
+                const key = `<error>[${Date.now()}]`;
+                return {
+                    [key]: [e.message, e.name],
+                };
+            }
+        }
+        else if (!this._EMPTY.includes(opt) || typeof opt !== 'object' || opt.constructor !== Object) {
+            const key = `<invalid-opt>[${Date.now()}]`;
+            return {
+                [key]: this.dev.secureJson(opt),
+            };
+        }
+        else {
+            return opt;
+        }
+    }
+    $runFn(fn, value, opt) {
+        try {
+            return fn(value());
+        }
+        catch (e) {
+            return this.$errorOrLog(opt, undefined, e);
+        }
+    }
+    $errorOrLog(opt, extra, e) {
+        var _a;
+        const newOpt = (_a = this.$runOpt(opt)) !== null && _a !== void 0 ? _a : {};
+        if (!newOpt.silent) {
+            delete newOpt.silent;
+            if (e instanceof Error) {
+                this.dev.native(e, newOpt, extra);
+            }
+            else {
+                this.dev.raise(newOpt, extra);
+            }
+        }
+        else {
+            if (e instanceof Error) {
+                this.dev.log(e, newOpt, 'warn');
+            }
+            else {
+                this.dev.log(newOpt, extra, 'warn');
+            }
+        }
+        return undefined;
+    }
+    $unexpectedError(value, expected, opt) {
+        return this.$errorOrLog(opt, { expected, type: typeof value, value });
+    }
+    // endregion secure
+    // region types
+    realNumber(value, opt) {
+        if (isNaN(value) || !isFinite(value)) {
+            return this.$errorOrLog(opt, { issue: 'invalid.real.number', value, type: typeof value });
+        }
+        return value;
+    }
+    any(value, opt) {
+        if (this._EMPTY.includes(value)) {
+            return value;
+        }
+        switch (typeof value) {
+            case 'string':
+            case 'boolean':
+            case 'bigint':
+            case 'object':
+                return value;
+            case 'number':
+                return this.realNumber(value, opt);
+            case 'function':
+                return this.$runFn(v => this.any(v, opt), value, opt);
+        }
+        return this.$unexpectedError(value, this._EXPECTED_ANY, opt);
+    }
+    list(value, opt, itemFn) {
+        if (this._EMPTY.includes(value)) {
+            return value;
+        }
+        switch (typeof value) {
+            case "string":
+            case "boolean":
+            case "number":
+            case "bigint":
+                return this.list([value], opt, itemFn);
+            case 'object':
+                if (value instanceof Set) {
+                    const newList = new list_1.List();
+                    if (value.size < 1) {
+                        return newList;
+                    }
+                    if (typeof itemFn !== "function") {
+                        newList.push(...Array.from(value.values()));
+                        return newList;
+                    }
+                    const clonedArr = this.array(Array.from(value.values()), opt, itemFn);
+                    if (clonedArr) {
+                        newList.push(...clonedArr);
+                    }
+                    return newList;
+                }
+                else if (value instanceof list_1.List) {
+                    if (typeof itemFn !== "function" || value.length < 1) {
+                        return value;
+                    }
+                    const clonedArr = this.array([...value], opt, itemFn);
+                    value.clear();
+                    if (clonedArr) {
+                        value.push(...clonedArr);
+                    }
+                    return value;
+                }
+                if (Array.isArray(value)) {
+                    const newList = new list_1.List();
+                    if (value.length < 1) {
+                        return newList;
+                    }
+                    if (typeof itemFn !== "function") {
+                        newList.push(...value);
+                        return newList;
+                    }
+                    const clonedArr = this.array(value, opt, itemFn);
+                    if (clonedArr) {
+                        newList.push(...clonedArr);
+                    }
+                    return newList;
+                }
+                break;
+            case 'function':
+                return this.$runFn(v => this.set(v, opt, itemFn), value, opt);
+        }
+        return this.$unexpectedError(value, this._EXPECTED_ARRAY, opt);
+    }
+    set(value, opt, itemFn) {
+        if (this._EMPTY.includes(value)) {
+            return value;
+        }
+        switch (typeof value) {
+            case "string":
+            case "boolean":
+            case "number":
+            case "bigint":
+                return this.set([value], opt, itemFn);
+            case 'object':
+                if (value instanceof Set) {
+                    if (typeof itemFn !== "function" || value.size < 1) {
+                        return value;
+                    }
+                    const clonedArr = this.array(Array.from(value.values()), opt, itemFn);
+                    value.clear();
+                    if (clonedArr) {
+                        clonedArr.forEach(item => value.add(item));
+                    }
+                    return value;
+                }
+                else if (value instanceof list_1.List) {
+                    if (value.length < 1) {
+                        return new Set();
+                    }
+                    if (typeof itemFn !== "function") {
+                        return new Set([...value]);
+                    }
+                    return new Set(this.array([...value], opt, itemFn));
+                }
+                if (Array.isArray(value)) {
+                    if (value.length < 1) {
+                        return new Set();
+                    }
+                    if (typeof itemFn !== "function") {
+                        return new Set(value);
+                    }
+                    return new Set(this.array(value, opt, itemFn));
+                }
+                break;
+            case 'function':
+                return this.$runFn(v => this.set(v, opt, itemFn), value, opt);
+        }
+        return this.$unexpectedError(value, this._EXPECTED_ARRAY, opt);
+    }
+    array(value, opt, itemFn) {
+        if (this._EMPTY.includes(value)) {
+            return value;
+        }
+        switch (typeof value) {
+            case "string":
+            case "boolean":
+            case "number":
+            case "bigint":
+                return this.array([value], opt, itemFn);
+            case 'object':
+                if (value instanceof Set) {
+                    if (value.size < 1) {
+                        return [];
+                    }
+                    return this.array(Array.from(value.values()), opt, itemFn);
+                }
+                else if (value instanceof list_1.List) {
+                    if (value.length < 1) {
+                        return [];
+                    }
+                    return this.array([...value], opt, itemFn);
+                }
+                if (Array.isArray(value)) {
+                    if (typeof itemFn !== "function" || value.length < 1) {
+                        return value;
+                    }
+                    const newOpt = this.$runOpt(opt);
+                    const field = (typeof newOpt.field === 'string') ? newOpt.field : undefined;
+                    const clonedOpt = Object.assign({}, newOpt);
+                    return value.map((v, index) => {
+                        clonedOpt.field = field ? `${field}#${index}` : `#${index}`;
+                        try {
+                            return itemFn(v, index, clonedOpt);
+                        }
+                        catch (e) {
+                            if (newOpt.silent) {
+                                this.dev.log(e, clonedOpt, 'warn');
+                            }
+                            else {
+                                this.dev.raise(e, clonedOpt);
+                            }
+                            return v;
+                        }
+                    });
+                }
+                return this.array([value], opt, itemFn);
+            case 'function':
+                return this.$runFn(v => this.array(v, opt, itemFn), value, opt);
+        }
+        return this.$unexpectedError(value, this._EXPECTED_ARRAY, opt);
+    }
+    boolean(value, opt) {
+        if (this._EMPTY.includes(value)) {
+            return value;
+        }
+        switch (typeof value) {
+            case 'boolean':
+                return value;
+            case 'string':
+                value = value.trim().toLowerCase();
+                if (value === '') {
+                    return undefined;
+                }
+                if (weak_true_1.WeakTrueItems.includes(value)) {
+                    return true;
+                }
+                if (weak_false_1.WeakFalseItems.includes(value)) {
+                    return false;
+                }
+                return this.$errorOrLog(opt, { issue: 'invalid.bool.text', value });
+            case 'number':
+                return value > 0;
+            case 'object':
+                if (Array.isArray(value) && value.length === 1) {
+                    return this.boolean(value[0], opt);
+                }
+                break;
+            case 'function':
+                return this.$runFn(v => this.boolean(v, opt), value, opt);
+        }
+        return this.$unexpectedError(value, this._EXPECTED_BOOL, opt);
+    }
+    date(value, opt) {
+        if (this._EMPTY.includes(value)) {
+            return value;
+        }
+        let fn;
+        switch (typeof value) {
+            case 'object':
+                if (value instanceof Date) {
+                    return value;
+                }
+                else if (typeof value['toDate'] === 'function') {
+                    fn = () => value['toDate']();
+                    return this.$runFn(v => this.date(v, opt), fn, opt);
+                }
+                if (Array.isArray(value)) {
+                    const arr = value;
+                    if (arr.length === 1) {
+                        return this.date(arr[0], opt);
+                    }
+                    if (arr.length > 1 && arr.length < 8) {
+                        const [year, monthIndex, date, hours, minutes, seconds, ms] = arr;
+                        fn = () => new Date(year, monthIndex, date, hours, minutes, seconds, ms);
+                        return this.$runFn(v => this.date(v, opt), fn, opt);
+                    }
+                }
+                else if (value.id !== undefined) {
+                    return this.date(value.id, opt);
+                }
+                break;
+            case 'string':
+                if (value.trim() === '') {
+                    return undefined;
+                }
+                fn = () => new Date(value.trim());
+                return this.$runFn(v => this.date(v, opt), fn, opt);
+            case 'bigint':
+                fn = () => new Date(value.toString(10));
+                return this.$runFn(v => this.date(v, opt), fn, opt);
+            case 'number':
+                fn = () => new Date(value);
+                return this.$runFn(v => this.date(v, opt), fn, opt);
+            case 'function':
+                return this.$runFn(v => this.date(v, opt), value, opt);
+        }
+        return this.$unexpectedError(value, this._EXPECTED_DATE, opt);
+    }
+    enumeration(value, map, opt, alt) {
+        if (this._EMPTY.includes(value)) {
+            return value;
+        }
+        if (!this.is.bareObject(map)) {
+            return this.$errorOrLog(opt, { issue: 'invalid.enum.map', type: typeof map, map });
+        }
+        let v;
+        switch (typeof value) {
+            case 'string':
+                value = value.trim();
+                if (value === '') {
+                    return undefined;
+                }
+                v = this._enumInMap(value, map);
+                if (!this._EMPTY.includes(v)) {
+                    return v;
+                }
+                if (this.is.bareObject(alt)) {
+                    v = this._enumInAlteration(value, alt);
+                    if (!this._EMPTY.includes(v)) {
+                        return v;
+                    }
+                }
+                return this.$unexpectedError(value, this._EXPECTED_ENUM, opt);
+            case 'number':
+                const num = this.realNumber(value, opt);
+                if (!this._EMPTY.includes(num)) {
+                    return null;
+                }
+                v = this._enumInMap(value, map);
+                if (!this._EMPTY.includes(v)) {
+                    return v;
+                }
+                if (this.is.bareObject(alt)) {
+                    v = this._enumInAlteration(value, alt);
+                    if (!this._EMPTY.includes(v)) {
+                        return v;
+                    }
+                }
+                return this.$unexpectedError(value, this._EXPECTED_ENUM, opt);
+            case 'object':
+                if (Array.isArray(value) && value.length === 1) {
+                    return this.enumeration(value[0], map, opt, alt);
+                }
+                return this.enumeration(value.id, map, opt, alt);
+            case 'function':
+                return this.$runFn(v => this.enumeration(v, map, opt, alt), value, opt);
+        }
+        return this.$unexpectedError(value, this._EXPECTED_ENUM, opt);
+    }
+    literal(value, items, opt, alt) {
+        if (this._EMPTY.includes(value)) {
+            return value;
+        }
+        if (!Array.isArray(items)) {
+            return this.$errorOrLog(opt, { issue: 'invalid.enum.literal', type: typeof items, items });
+        }
+        let v;
+        switch (typeof value) {
+            case 'string':
+                value = value.trim();
+                if (value === '') {
+                    return undefined;
+                }
+                v = this._enumInArray(value, items);
+                if (!this._EMPTY.includes(v)) {
+                    return v;
+                }
+                if (this.is.bareObject(alt)) {
+                    v = this._enumInAlteration(value, alt);
+                    if (!this._EMPTY.includes(v)) {
+                        return v;
+                    }
+                }
+                return this.$unexpectedError(value, this._EXPECTED_ENUM, opt);
+            case 'number':
+                const num = this.realNumber(value, opt);
+                if (!this._EMPTY.includes(num)) {
+                    return null;
+                }
+                v = this._enumInArray(value, items);
+                if (!this._EMPTY.includes(v)) {
+                    return v;
+                }
+                if (this.is.bareObject(alt)) {
+                    v = this._enumInAlteration(value, alt);
+                    if (!this._EMPTY.includes(v)) {
+                        return v;
+                    }
+                }
+                return this.$unexpectedError(value, this._EXPECTED_ENUM, opt);
+            case 'object':
+                if (Array.isArray(value) && value.length === 1) {
+                    return this.literal(value[0], items, opt, alt);
+                }
+                return this.literal(value.id, items, opt, alt);
+            case 'function':
+                return this.$runFn(v => this.literal(v, items, opt, alt), value, opt);
+        }
+        return this.$unexpectedError(value, this._EXPECTED_ENUM, opt);
+    }
+    float(value, opt) {
+        if (this._EMPTY.includes(value)) {
+            return value;
+        }
+        let fn;
+        switch (typeof value) {
+            case 'string':
+                fn = () => parseFloat(value);
+                return this.$runFn(v => this.float(v, opt), fn, opt);
+            case 'number':
+                return this.realNumber(value, opt);
+            case 'bigint':
+                fn = () => Number(value);
+                return this.$runFn(v => this.float(v, opt), fn, opt);
+            case 'boolean':
+                return value ? 1 : 0;
+            case 'object':
+                if (Array.isArray(value) && value.length === 1) {
+                    return this.float(value[0], opt);
+                }
+                return this.float(value.id, opt);
+            case 'function':
+                return this.$runFn(v => this.float(v, opt), value, opt);
+        }
+        return this.$unexpectedError(value, this._EXPECTED_NUMBER, opt);
+    }
+    func(value, opt) {
+        if (this._EMPTY.includes(value)) {
+            return value;
+        }
+        switch (typeof value) {
+            case "function":
+                return value;
+            case 'object':
+                if (this.wrapper.isFunction(value)) {
+                    return this.wrapper.asFunction(value);
+                }
+                if (Array.isArray(value) && value.length === 1) {
+                    return this.func(value[0], opt);
+                }
+                break;
+        }
+        return this.$unexpectedError(value, ['function'], opt);
+    }
+    integer(value, opt) {
+        if (this._EMPTY.includes(value)) {
+            return value;
+        }
+        let fn;
+        switch (typeof value) {
+            case 'string':
+                fn = () => parseInt(value);
+                return this.$runFn(v => this.integer(v, opt), fn, opt);
+            case 'number':
+                let num = this.realNumber(value, opt);
+                if (num !== null && !Number.isSafeInteger(num)) {
+                    num = Math.floor(num);
+                }
+                return num;
+            case 'bigint':
+                fn = () => Number(value);
+                return this.$runFn(v => this.integer(v, opt), fn, opt);
+            case 'boolean':
+                return value ? 1 : 0;
+            case 'object':
+                if (Array.isArray(value) && value.length === 1) {
+                    return this.integer(value[0], opt);
+                }
+                return this.integer(value.id, opt);
+            case 'function':
+                return this.$runFn(v => this.integer(v, opt), value, opt);
+        }
+        return this.$unexpectedError(value, this._EXPECTED_NUMBER, opt);
+    }
+    object(value, opt) {
+        return this.dict(value, opt);
+    }
+    map(value, opt, valueFn, keyFn) {
+        if (this._EMPTY.includes(value)) {
+            return value;
+        }
+        switch (typeof value) {
+            case 'object':
+                if (value instanceof Set) {
+                    if (value.size === 1) {
+                        return this.map(Array.from(value.values())[0], opt, valueFn, keyFn);
+                    }
+                }
+                else if (value instanceof list_1.List) {
+                    if (value.length === 1) {
+                        return this.map(value[0], opt, valueFn, keyFn);
+                    }
+                }
+                else if (value instanceof Map) {
+                    if (typeof valueFn !== "function" && typeof keyFn !== "function") {
+                        return value;
+                    }
+                    if (value.size < 1) {
+                        return value;
+                    }
+                    const newOpt = this.$runOpt(opt);
+                    const field = (typeof newOpt.field === 'string') ? newOpt.field : undefined;
+                    const clonedOpt = Object.assign({}, newOpt);
+                    const cloned = Object.fromEntries(value.entries());
+                    let index = -1;
+                    value.clear();
+                    for (const [k, v] of Object.entries(cloned)) {
+                        if (typeof k === 'symbol') {
+                            continue;
+                        }
+                        index++;
+                        let newKey = k;
+                        let newValue = v;
+                        if (typeof keyFn === 'function') {
+                            clonedOpt.field = field ? `${field}#${index}` : `#${index}`;
+                            try {
+                                newKey = keyFn(k, index, clonedOpt);
+                            }
+                            catch (e) {
+                                this.$errorOrLog(clonedOpt, undefined, e);
+                            }
+                            if (this._EMPTY.includes(newKey)) {
+                                continue;
+                            }
+                        }
+                        if (typeof valueFn === 'function') {
+                            clonedOpt.field = field ? `${field}.${k}` : k;
+                            try {
+                                newValue = valueFn(v, k, clonedOpt);
+                            }
+                            catch (e) {
+                                this.$errorOrLog(clonedOpt, undefined, e);
+                            }
+                        }
+                        value.set(newKey, newValue);
+                    }
+                    return value;
+                }
+                else if (Array.isArray(value)) {
+                    if (value.length === 1) {
+                        return this.map(value[0], opt, valueFn, keyFn);
+                    }
+                }
+                else if (this.is.bareObject(value)) {
+                    const newMap = new Map();
+                    const keys = Object.keys(value);
+                    if (keys.length < 1) {
+                        return newMap;
+                    }
+                    for (const [k, v] of Object.entries(value)) {
+                        newMap.set(k, v);
+                    }
+                    return this.map(newMap, opt, valueFn, keyFn);
+                }
+                break;
+            case 'function':
+                return this.$runFn(v => this.map(v, opt, valueFn, keyFn), value, opt);
+        }
+        return this.$unexpectedError(value, this._EXPECTED_OBJECT, opt);
+    }
+    dict(value, opt, valueFn, keyFn) {
+        if (this._EMPTY.includes(value)) {
+            return value;
+        }
+        switch (typeof value) {
+            case 'object':
+                if (value instanceof Set) {
+                    if (value.size === 1) {
+                        return this.dict(Array.from(value.values())[0], opt, valueFn, keyFn);
+                    }
+                }
+                else if (value instanceof list_1.List) {
+                    if (value.length === 1) {
+                        return this.dict(value[0], opt, valueFn, keyFn);
+                    }
+                }
+                else if (value instanceof Map) {
+                    if (value.size < 1) {
+                        return {};
+                    }
+                    return this.dict(Object.fromEntries(value.entries()), opt, valueFn, keyFn);
+                }
+                else if (Array.isArray(value)) {
+                    if (value.length === 1) {
+                        return this.dict(value[0], opt, valueFn, keyFn);
+                    }
+                }
+                else if (this.is.bareObject(value)) {
+                    if (typeof valueFn !== "function" && typeof keyFn !== "function") {
+                        return value;
+                    }
+                    const keys = Object.keys(value);
+                    if (keys.length < 1) {
+                        return value;
+                    }
+                    const newOpt = this.$runOpt(opt);
+                    const field = (typeof newOpt.field === 'string') ? newOpt.field : undefined;
+                    const clonedOpt = Object.assign({}, newOpt);
+                    const cloned = Object.assign({}, value);
+                    keys
+                        .filter(k => typeof k !== 'symbol')
+                        .forEach(k => {
+                        try {
+                            delete value[k];
+                        }
+                        catch (e) {
+                        }
+                    });
+                    let index = -1;
+                    for (const [k, v] of Object.entries(cloned)) {
+                        if (typeof k === 'symbol') {
+                            continue;
+                        }
+                        index++;
+                        let newKey = k;
+                        let newValue = v;
+                        if (typeof keyFn === 'function') {
+                            clonedOpt.field = field ? `${field}#${index}` : `#${index}`;
+                            try {
+                                newKey = keyFn(k, index, clonedOpt);
+                            }
+                            catch (e) {
+                                this.$errorOrLog(clonedOpt, undefined, e);
+                            }
+                            if (this._EMPTY.includes(newKey)) {
+                                continue;
+                            }
+                        }
+                        if (typeof valueFn === 'function') {
+                            clonedOpt.field = field ? `${field}.${k}` : k;
+                            try {
+                                newValue = valueFn(v, k, clonedOpt);
+                            }
+                            catch (e) {
+                                this.$errorOrLog(clonedOpt, undefined, e);
+                            }
+                        }
+                        try {
+                            value[newKey] = newValue;
+                        }
+                        catch (e) {
+                        }
+                    }
+                    return value;
+                }
+                // other objects, don't toch
+                return value;
+            case 'function':
+                return this.$runFn(v => this.dict(v, opt, valueFn, keyFn), value, opt);
+        }
+        return this.$unexpectedError(value, this._EXPECTED_OBJECT, opt);
+    }
+    string(value, opt) {
+        if (this._EMPTY.includes(value)) {
+            return value;
+        }
+        switch (typeof value) {
+            case 'string':
+                return value;
+            case 'number':
+                const num = this.realNumber(value, opt);
+                return this._EMPTY.includes(num) ? num : num.toString(10);
+            case 'bigint':
+                return value.toString();
+            case 'boolean':
+                return value ? 'true' : 'false';
+            case 'object':
+                if (Array.isArray(value) && value.length === 1) {
+                    return this.string(value[0], opt);
+                }
+                return this.string(value.id, opt);
+            case 'function':
+                return this.$runFn(v => this.string(v, opt), value, opt);
+        }
+        return this.$unexpectedError(value, this._EXPECTED_STRING, opt);
+    }
+    text(value, opt) {
+        if (this._EMPTY.includes(value)) {
+            return value;
+        }
+        switch (typeof value) {
+            case 'string':
+                const str = value.trim();
+                return str ? str : undefined;
+            case 'number':
+                const num = this.realNumber(value, opt);
+                return this._EMPTY.includes(num) ? num : num.toString(10);
+            case 'bigint':
+                return value.toString();
+            case 'boolean':
+                return value ? 'true' : 'false';
+            case 'object':
+                if (Array.isArray(value) && value.length === 1) {
+                    return this.text(value[0], opt);
+                }
+                return this.text(value.id, opt);
+            case 'function':
+                return this.$runFn(v => this.text(v, opt), value, opt);
+        }
+        return this.$unexpectedError(value, this._EXPECTED_STRING, opt);
+    }
+}
+exports.CommonTo = CommonTo;
+//# sourceMappingURL=common-to.js.map