baja-lite 1.3.27 → 1.3.28

package/{src/convert-xml.ts → convert-xml.js}

@@ -1,39 +1,30 @@
 import LGet from 'lodash.get';
-export interface XML {
-    type: 'tag' | 'text';
-    name: string;
-    id?: string;
-    voidElement: boolean;
-    attrs: Record<string, string>;
-    children: XML[];
-    content: string;
-}
-export const convert = function (childrens: XML[], param: Record<string, any>, parentIds: string[], myBatisMapper: Record<string, XML[]>) {
+export const convert = function (childrens, param, parentIds, myBatisMapper) {
     let statement = '';
-    for (let i = 0, children: XML; children = childrens[i]!; i++) {
+    for (let i = 0, children; children = childrens[i]; i++) {
         // Convert SQL statement recursively
         statement += convertChildren(children, param, parentIds, myBatisMapper);
     }
     // Check not converted Parameters
     const regexList = ['\\#{\\S*}', '\\${\\S*}'];
-    for (let i = 0, regexString: string; regexString = regexList[i]!; i++) {
+    for (let i = 0, regexString; regexString = regexList[i]; i++) {
         var checkParam = statement.match(regexString);
         if (checkParam != null && checkParam.length > 0) {
             throw new Error("Parameter " + checkParam.join(",") + " is not converted.");
         }
     }
     return statement;
-}
-const convertChildren = function (children: XML, param: Record<string, any>, parentIds: string[], myBatisMapper: Record<string, XML[]>) {
-    param ??= {};
+};
+const convertChildren = function (children, param, parentIds, myBatisMapper) {
+    param ?? (param = {});
     if (!isDict(param)) {
         throw new Error('Parameter argument should be Key-Value type or Null.');
     }
     if (children.type == 'text') {
         // Convert Parameters
         return convertParameters(children, param);
-
-    } else if (children.type == 'tag') {
+    }
+    else if (children.type == 'tag') {
         switch (children.name.toLowerCase()) {
             case 'if':
                 return convertIf(children, param, parentIds, myBatisMapper);
@@ -54,74 +45,69 @@ const convertChildren = function (children: XML, param: Record<string, any>, par
             default:
                 throw new Error('XML is not well-formed character or markup. Consider using CDATA section.');
         }
-    } else {
+    }
+    else {
         return '';
     }
-}
-
-const convertParameters = function (children: XML, param: Record<string, any>) {
+};
+const convertParameters = function (children, param) {
     let convertString = children.content;
-
     try {
         convertString = convertParametersInner('#', convertString, param);
         convertString = convertParametersInner('$', convertString, param);
-    } catch (err) {
+    }
+    catch (err) {
         throw new Error('Error occurred during convert parameters.');
     }
-
     try {
         // convert CDATA string
         convertString = convertString.replace(/(\&amp\;)/g, '&');
         convertString = convertString.replace(/(\&lt\;)/g, '<');
         convertString = convertString.replace(/(\&gt\;)/g, '>');
         convertString = convertString.replace(/(\&quot\;)/g, '"');
-    } catch (err) {
+    }
+    catch (err) {
         throw new Error('Error occurred during convert CDATA section.');
     }
-
     return convertString;
-}
-
-const isObject = function (variable: any) {
+};
+const isObject = function (variable) {
     return typeof variable === 'object' && variable !== null;
-}
-
-const isArray = function (variable: any) {
+};
+const isArray = function (variable) {
     return isObject(variable) && variable.hasOwnProperty('length');
-}
-
-const convertParametersInner = function (change: string, convertString: string, param: Record<string, any>) {
+};
+const convertParametersInner = function (change, convertString, param) {
     const stringReg = new RegExp('(\\' + change + '\\{[a-zA-Z0-9._\\$]+\\})', 'g');
     let stringTarget = convertString.match(stringReg);
-
     if (stringTarget != null && stringTarget.length > 0) {
         const _stringTarget = uniqueArray(stringTarget);
-
-        let target: string | undefined;
+        let target;
         for (let i = 0; i < _stringTarget.length; i++) {
             target = _stringTarget[i];
-            const t = target!.replace(change + '{', '').replace('}', '');
+            const t = target.replace(change + '{', '').replace('}', '');
             let tempParamKey = LGet(param, t);
             if (tempParamKey !== undefined) {
                 const reg = new RegExp('\\' + change + '{' + t + '}', 'g');
-
                 if (tempParamKey === null) {
                     tempParamKey = 'NULL';
                     convertString = convertString.replace(reg, tempParamKey);
-                } else {
+                }
+                else {
                     if (change == '#') {
                         // processing JSON fields structures
                         if (isObject(tempParamKey) || isArray(tempParamKey)) {
                             tempParamKey = JSON.stringify(tempParamKey);
-                        } else {
+                        }
+                        else {
                             tempParamKey = tempParamKey.toString().replace(/"/g, '\\\"');
                             tempParamKey = mysqlRealEscapeParam(tempParamKey);
                         }
-
                         tempParamKey = tempParamKey.replace(/'/g, "''");
-                        const replaceWith = "'" + tempParamKey + "'"
+                        const replaceWith = "'" + tempParamKey + "'";
                         convertString = convertString.replace(reg, () => replaceWith);
-                    } else if (change == '$') {
+                    }
+                    else if (change == '$') {
                         convertString = convertString.replace(reg, tempParamKey);
                     }
                 }
@@ -129,134 +115,122 @@ const convertParametersInner = function (change: string, convertString: string,
         }
     }
     return convertString;
-}
-
-const convertIf = function (children: XML, param: Record<string, any>, parentIds: string[], myBatisMapper: Record<string, XML[]>) {
-    let evalString = children.attrs['test']!;
+};
+const convertIf = function (children, param, parentIds, myBatisMapper) {
+    let evalString = children.attrs['test'];
     try {
         // Create Evaluate string
         evalString = replaceEvalString(evalString, param);
-
         evalString = evalString.replace(/ and /gi, ' && ');
         evalString = evalString.replace(/ or /gi, ' || ');
-
         // replace == to === for strict evaluate
         // TODO: fix != null & != ''
         // evalString = evalString.replace(/==/g, '===');
         // evalString = evalString.replace(/!=/g, '!==');
-
         evalString = evalString.replace(/^'(.*?)'\.equalsIgnoreCase\( ([a-zA-Z]+\.[a-zA-Z]+) \)/i, `($2 && $2.toUpperCase() === '$1'.toUpperCase())`);
         evalString = evalString.replace(/\('(.*?)'\.equalsIgnoreCase\( ([a-zA-Z]+\.[a-zA-Z]+) \)/i, `(($2 && $2.toUpperCase() === '$1'.toUpperCase())`);
-
-    } catch (err) {
+    }
+    catch (err) {
         throw new Error('Error occurred during convert <if> element.');
     }
-
     // Execute Evaluate string
     try {
         if (eval(evalString)) {
             let convertString = '';
-            for (let i = 0, nextChildren: XML; nextChildren = children['children'][i]!; i++) {
+            for (let i = 0, nextChildren; nextChildren = children['children'][i]; i++) {
                 convertString += convertChildren(nextChildren, param, parentIds, myBatisMapper);
             }
             return convertString;
-
-        } else {
+        }
+        else {
             return '';
         }
-    } catch (e) {
+    }
+    catch (e) {
         return '';
     }
-}
-
-const convertForeach = function (children: XML, param: Record<string, any>, parentIds: string[], myBatisMapper: Record<string, XML[]>) {
+};
+const convertForeach = function (children, param, parentIds, myBatisMapper) {
     try {
         const collection = eval('param.' + children.attrs['collection']);
-        const item = children.attrs['item']!;
+        const item = children.attrs['item'];
         const open = (children.attrs['open'] == null) ? '' : children.attrs['open'];
         const close = (children.attrs['close'] == null) ? '' : children.attrs['close'];
         const separator = (children.attrs['separator'] == null) ? '' : children.attrs['separator'];
-
-        const foreachTexts: string[] = [];
+        const foreachTexts = [];
         let coll = null;
         for (let j = 0; j < collection.length; j++) {
             coll = collection[j];
             const foreachParam = param;
             foreachParam[item] = coll;
-
             let foreachText = '';
-            for (let k = 0, nextChildren: XML; nextChildren = children.children[k]!; k++) {
+            for (let k = 0, nextChildren; nextChildren = children.children[k]; k++) {
                 let fText = convertChildren(nextChildren, foreachParam, parentIds, myBatisMapper);
                 fText = fText.replace(/^\s*$/g, '');
                 if (fText != null && fText.length > 0) {
                     foreachText += fText;
                 }
             }
-
             if (foreachText != null && foreachText.length > 0) {
                 foreachTexts.push(foreachText);
             }
         }
-
         return (open + foreachTexts.join(separator) + close);
-    } catch (err) {
+    }
+    catch (err) {
         throw new Error('Error occurred during convert <foreach> element.');
     }
-}
-
-const convertChoose = function (children: XML, param: Record<string, any>, parentIds: string[], myBatisMapper: Record<string, XML[]>) {
+};
+const convertChoose = function (children, param, parentIds, myBatisMapper) {
     try {
         for (let i = 0, whenChildren; whenChildren = children.children[i]; i++) {
             if (whenChildren.type == 'tag' && whenChildren.name.toLowerCase() == 'when') {
                 let evalString = whenChildren.attrs.test;
-
                 // Create Evaluate string
                 evalString = replaceEvalString(evalString, param);
-
                 evalString = evalString.replace(/ and /gi, ' && ');
                 evalString = evalString.replace(/ or /gi, ' || ');
-
                 // Execute Evaluate string
                 try {
                     if (eval(evalString)) {
                         // If <when> condition is true, do it.
                         let convertString = '';
-                        for (let k = 0, nextChildren: XML; nextChildren = whenChildren.children[k]; k++) {
+                        for (let k = 0, nextChildren; nextChildren = whenChildren.children[k]; k++) {
                             convertString += convertChildren(nextChildren, param, parentIds, myBatisMapper);
                         }
                         return convertString;
-                    } else {
+                    }
+                    else {
                         continue;
                     }
-                } catch (e) {
+                }
+                catch (e) {
                     continue;
                 }
-            } else if (whenChildren.type == 'tag' && whenChildren.name.toLowerCase() == 'otherwise') {
+            }
+            else if (whenChildren.type == 'tag' && whenChildren.name.toLowerCase() == 'otherwise') {
                 // If reached <otherwise> tag, do it.
                 let convertString = '';
-                for (let k = 0, nextChildren: XML; nextChildren = whenChildren.children[k]; k++) {
+                for (let k = 0, nextChildren; nextChildren = whenChildren.children[k]; k++) {
                     convertString += convertChildren(nextChildren, param, parentIds, myBatisMapper);
                 }
                 return convertString;
             }
         }
-
         // If there is no suitable when and otherwise, just return null.
         return '';
-
-    } catch (err) {
+    }
+    catch (err) {
         throw new Error('Error occurred during convert <choose> element.');
     }
-}
-
-const convertTrimWhere = function (children: XML, param: Record<string, any>, parentIds: string[], myBatisMapper: Record<string, XML[]>) {
+};
+const convertTrimWhere = function (children, param, parentIds, myBatisMapper) {
     let convertString = '';
-    let prefix: string | undefined;
-    let prefixOverrides: string | undefined;
-    let suffix: string | undefined;
-    let suffixOverrides: string | undefined;
-    let globalSet: string | undefined;
-
+    let prefix;
+    let prefixOverrides;
+    let suffix;
+    let suffixOverrides;
+    let globalSet;
     try {
         switch (children.name.toLowerCase()) {
             case 'trim':
@@ -274,102 +248,86 @@ const convertTrimWhere = function (children: XML, param: Record<string, any>, pa
             default:
                 throw new Error('Error occurred during convert <trim/where> element.');
         }
-
         // Convert children first.
-        for (let j = 0, nextChildren: XML; nextChildren = children.children[j]!; j++) {
+        for (let j = 0, nextChildren; nextChildren = children.children[j]; j++) {
             convertString += convertChildren(nextChildren, param, parentIds, myBatisMapper);
         }
-
         // Remove prefixOverrides
         let trimRegex = new RegExp('(^)([\\s]*?)(' + prefixOverrides + ')', globalSet);
         convertString = convertString.replace(trimRegex, '');
         // Remove suffixOverrides
         trimRegex = new RegExp('(' + suffixOverrides + ')([\\s]*?)($)', globalSet);
         convertString = convertString.replace(trimRegex, '');
-
         if (children.name.toLowerCase() != 'trim') {
             trimRegex = new RegExp('(' + prefixOverrides + ')([\\s]*?)($)', globalSet);
             convertString = convertString.replace(trimRegex, '');
         }
-
         // Add Prefix if String is not empty.
         trimRegex = new RegExp('([a-zA-Z])', 'g');
         const w = convertString.match(trimRegex);
-
         if (w != null && w.length > 0) {
             convertString = prefix + ' ' + convertString;
             if (suffix) {
-                convertString = convertString + ' ' + suffix
+                convertString = convertString + ' ' + suffix;
             }
         }
-
         // Remove comma(,) before WHERE
         if (children.name.toLowerCase() != 'where') {
             const regex = new RegExp('(,)([\\s]*?)(where)', 'gi');
             convertString = convertString.replace(regex, ' WHERE ');
         }
-
         return convertString;
-    } catch (err) {
+    }
+    catch (err) {
         throw new Error('Error occurred during convert <' + children.name.toLowerCase() + '> element.');
     }
-}
-
-const convertSet = function (children: XML, param: Record<string, any>, parentIds: string[], myBatisMapper: Record<string, XML[]>) {
+};
+const convertSet = function (children, param, parentIds, myBatisMapper) {
     let convertString = '';
-
     try {
         // Convert children first.
-        for (let j = 0, nextChildren: XML; nextChildren = children.children[j]!; j++) {
+        for (let j = 0, nextChildren; nextChildren = children.children[j]; j++) {
             convertString += convertChildren(nextChildren, param, parentIds, myBatisMapper);
         }
-
         // Remove comma repeated more than 2.
         let regex = new RegExp('(,)(,|\\s){2,}', 'g');
         convertString = convertString.replace(regex, ',\n');
-
         // Remove first comma if exists.
         regex = new RegExp('(^)([\\s]*?)(,)', 'g');
         convertString = convertString.replace(regex, '');
-
         // Remove last comma if exists.
         regex = new RegExp('(,)([\\s]*?)($)', 'g');
         convertString = convertString.replace(regex, '');
-
         convertString = ' SET ' + convertString;
         return convertString;
-    } catch (err) {
+    }
+    catch (err) {
         throw new Error('Error occurred during convert <set> element.');
     }
-}
-
-const convertBind = function (children: XML, param: Record<string, any>) {
-    let evalString = children.attrs["value"]!;
-
+};
+const convertBind = function (children, param) {
+    let evalString = children.attrs["value"];
     // Create Evaluate string
     evalString = replaceEvalString(evalString, param);
-
-    param[children.attrs["name"]!] = eval(evalString);
-
+    param[children.attrs["name"]] = eval(evalString);
     return param;
-}
-
-const convertInclude = function (children: XML, param: Record<string, any>, parentIds: string[], myBatisMapper: Record<string, XML[]>) {
+};
+const convertInclude = function (children, param, parentIds, myBatisMapper) {
     try {
         // Add Properties to param
-        for (let j = 0, nextChildren: XML; nextChildren = children.children[j]!; j++) {
+        for (let j = 0, nextChildren; nextChildren = children.children[j]; j++) {
             if (nextChildren.type == 'tag' && nextChildren.name == 'property') {
-                param[nextChildren.attrs['name']!] = nextChildren.attrs['value'];
+                param[nextChildren.attrs['name']] = nextChildren.attrs['value'];
             }
         }
-    } catch (err) {
+    }
+    catch (err) {
         throw new Error('Error occurred during read <property> element in <include> element.');
     }
-
     try {
-        let refid = convertParametersInner('#', children.attrs['refid']!, param);
+        let refid = convertParametersInner('#', children.attrs['refid'], param);
         refid = convertParametersInner('$', refid, param);
-        let mapper: XML[] | undefined;
+        let mapper;
         for (const psqlid of parentIds) {
             mapper = myBatisMapper[`${psqlid}.${refid}`];
             if (mapper) {
@@ -377,34 +335,30 @@ const convertInclude = function (children: XML, param: Record<string, any>, pare
             }
         }
         let statement = '';
-        for (let i = 0, children: XML; children = mapper![i]!; i++) {
+        for (let i = 0, children; children = mapper[i]; i++) {
             statement += convertChildren(children, param, parentIds, myBatisMapper);
         }
         return statement;
-    } catch (err) {
+    }
+    catch (err) {
         throw new Error('Error occurred during convert refid attribute in <include> element.');
     }
-
-}
-
-const isDict = function (v: any) {
+};
+const isDict = function (v) {
     return typeof v === 'object' && v !== null && !(v instanceof Array) && !(v instanceof Date);
-}
-
-const replaceEvalString = function (evalString: string, param: Record<string, any>) {
+};
+const replaceEvalString = function (evalString, param) {
     const keys = Object.keys(param);
-
     for (let i = 0; i < keys.length; i++) {
         let replacePrefix = '';
         let replacePostfix = '';
-        let paramRegex: RegExp | undefined;
-
-        if (isDict(param[keys[i]!])) {
+        let paramRegex;
+        if (isDict(param[keys[i]])) {
             replacePrefix = ' param.';
             replacePostfix = '';
-
             paramRegex = new RegExp('(^|[^a-zA-Z0-9_])(' + keys[i] + '\\.)([a-zA-Z0-9_]+)', 'g');
-        } else {
+        }
+        else {
             replacePrefix = ' param.';
             replacePostfix = ' ';
             paramRegex = new RegExp('(^|[^a-zA-Z0-9_])(' + keys[i] + ')($|[^a-zA-Z0-9_])', 'g');
@@ -412,27 +366,24 @@ const replaceEvalString = function (evalString: string, param: Record<string, an
         evalString = evalString.replace(paramRegex, ('$1' + replacePrefix + '$2' + replacePostfix + '$3'));
     }
     return evalString;
-}
-
-const uniqueArray = function (a: RegExpMatchArray) {
+};
+const uniqueArray = function (a) {
     const seen = {};
-    const out: string[] = [];
+    const out = [];
     const len = a.length;
     let j = 0;
     for (let i = 0; i < len; i++) {
-        const item = a[i]!;
+        const item = a[i];
         if (seen[item] !== 1) {
             seen[item] = 1;
             out[j++] = item;
         }
     }
     return out;
-}
-
+};
 const mysqlRealEscapeParam = function (param) {
     if (typeof param != 'string')
         return param;
-
     return param.replace(/[\0\x08\x09\x1a\n\r''\\\%]/g, function (char) {
         switch (char) {
             case '\0':
@@ -456,5 +407,4 @@ const mysqlRealEscapeParam = function (param) {
                 return char;
         }
     });
-}
-
+};

package/enum.d.ts

@@ -0,0 +1,18 @@
+export declare class Enum {
+    private _value;
+    private _desc;
+    private _config;
+    constructor(value: string, desc: string, ...config: string[]);
+    eq(value: string | number | undefined | null): boolean;
+    value(): string;
+    desc(): string;
+    config(): string[];
+}
+export type EnumMap = Record<string, Enum>;
+export type GlobalArray = Record<string, Array<[string, string]>>;
+export type GlobalMap = Record<string, Record<string, string>>;
+export interface EnmuJson {
+    GlobalArray: GlobalArray;
+    GlobalMap: GlobalMap;
+}
+export declare const getEnums: (GlobalValues?: EnumMap) => EnmuJson;

package/enum.js

@@ -0,0 +1,59 @@
+import { _enums } from "./sql.js";
+export class Enum {
+    constructor(value, desc, ...config) {
+        this._value = value;
+        this._desc = desc;
+        this._config = config;
+    }
+    eq(value) {
+        if (value === undefined) {
+            return false;
+        }
+        if (value === null) {
+            return false;
+        }
+        if (typeof value === 'number') {
+            return this._value === `${value}`;
+        }
+        return this._value === `${value}`;
+    }
+    value() {
+        return this._value;
+    }
+    desc() {
+        return this._desc;
+    }
+    config() {
+        return this._config;
+    }
+}
+let configData = null;
+export const getEnums = (GlobalValues) => {
+    if (!GlobalValues) {
+        return globalThis[_enums];
+    }
+    if (configData) {
+        return configData;
+    }
+    const result = {
+        GlobalArray: {},
+        GlobalMap: {}
+    };
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+    Object.keys(GlobalValues).forEach((item) => {
+        // const guess = /([\w\W]+)_([^_]+)$/.exec(item);
+        const guess = item.replace(new RegExp(`_${GlobalValues[item].value()}`, 'i'), '');
+        if (guess) {
+            if (!result.GlobalArray[guess]) {
+                result.GlobalArray[guess] = [];
+            }
+            result.GlobalArray[guess].push([GlobalValues[item].value(), GlobalValues[item].desc()]);
+            if (!result.GlobalMap[guess]) {
+                result.GlobalMap[guess] = {};
+            }
+            result.GlobalMap[guess][GlobalValues[item].value()] = GlobalValues[item].desc();
+        }
+    });
+    configData = result;
+    return result;
+};

package/error.d.ts

@@ -0,0 +1,5 @@
+export declare const Throw: {
+    if(test: boolean, message: string | Error | any): void;
+    ifNot(test: boolean, message: string | Error | any): void;
+    now(message: string | Error | any): never;
+};

package/error.js

@@ -0,0 +1,13 @@
+export const Throw = {
+    if(test, message) {
+        if (test === true)
+            this.now(message);
+    },
+    ifNot(test, message) {
+        if (test !== true)
+            this.now(message);
+    },
+    now(message) {
+        throw typeof message === 'string' ? new Error(message) : message;
+    }
+};