@trustme24/flext 1.10.1 → 1.10.2

package/src/modules/math/index.ts

@@ -0,0 +1,198 @@
+import {audit, sum, defineModule, isNumber} from '@/lib';
+import {BaseError, TemplateSyntaxError} from '@/errors';
+
+
+// Types
+
+export type Arg = string|number|null|undefined;
+
+export type FlattenFuncArg = number | number[];
+
+
+// Functions
+
+export function op(state: any): number {
+    const args: Arg[] = state?.args ?? [];
+    const [ a, op, b, ...rest ] = args;
+
+
+    // Defining the functions
+
+    const handle = (..._args: Arg[]): number => {
+        const [ mathOp, ...mathArgs ] = _args;
+        const handle = Math[mathOp] ?? null;
+
+        if (handle)
+            return handle(...mathArgs);
+        else
+            throw new TemplateSyntaxError('Math: Unknown operation: ' + audit(mathOp));
+    }
+
+    const flatten = (..._args: FlattenFuncArg[] | any[]): number[] => {
+        const result: number[] = [];
+
+        for (const arg of _args) {
+            if (isNumber(arg))
+                result.push(arg);
+            else if (Array.isArray(arg) && arg.every(isNumber))
+                result.push(...arg);
+            else
+                throw new BaseError('Math: Unable to sum: The given arguments are not numbers: ' + audit(_args));
+        }
+
+        return result;
+    };
+
+
+    // Applying the operation
+
+    switch (op) {
+        case 'plus':
+        case 'sum':
+            return sum(...flatten(a, b || 0, ...rest));
+        case 'minus':
+            return Number(a) - Number(b || 0);
+        case 'multiply':
+            return Number(a) * Number(b || 1);
+        case 'divide':
+            return Number(a) / Number(b || 1);
+        case 'intDivide':
+            return Number(a) % Number(b || 1);
+        case 'power':
+            return Number(a) ** Number(b || 1);
+        default:
+            return handle(...args);
+    }
+}
+
+export function plus(state: any): number {
+    const args: Arg[] = state?.args ?? [];
+    const [ a, b, ...rest ] = args;
+
+    return op({ ...state, args: [ a, 'plus', b, ...rest ] });
+}
+
+export function _sum(state: any): number {
+    const args: Arg[] = state?.args ?? [];
+    const [ a, b, ...rest ] = args;
+
+    return op({ ...state, args: [ a, 'sum', b, ...rest ] });
+}
+
+export function minus(state: any): number {
+    const args: Arg[] = state?.args ?? [];
+    const [ a, b ] = args;
+
+    return op({ ...state, args: [ a, 'minus', b ] });
+}
+
+export function multiply(state: any): number {
+    const args: Arg[] = state?.args ?? [];
+    const [ a, b ] = args;
+
+    return op({ ...state, args: [ a, 'multiply', b ] });
+}
+
+export function divide(state: any): number {
+    const args: Arg[] = state?.args ?? [];
+    const [ a, b ] = args;
+
+    return op({ ...state, args: [ a, 'divide', b ] });
+}
+
+export function intDivide(state: any): number {
+    const args: Arg[] = state?.args ?? [];
+    const [ a, b ] = args;
+
+    return op({ ...state, args: [ a, 'intDivide', b ] });
+}
+
+export function power(state: any): number {
+    const args: Arg[] = state?.args ?? [];
+    const [ a, b ] = args;
+
+    return op({ ...state, args: [ a, 'power', b ] });
+}
+
+export function round(state: any): number {
+    const args: Arg[] = state?.args ?? [];
+    const [ a, _op ] = args;
+
+
+    // Defining the function
+
+    const handle = (__op: string, val: Arg): number => op({ ...state, args: [ __op, val ] });
+
+
+    // If the operation is not defined
+
+    if (!_op) return handle('round', a);
+
+
+    // Applying the operation
+
+    switch (_op) {
+        case 'floor':
+            return handle('floor', a);
+        case 'ceil':
+            return handle('ceil', a);
+        case 'trunc':
+            return handle('trunc', a);
+        default:
+            throw new TemplateSyntaxError('Math: Unknown operation: ' + audit(_op));
+    }
+}
+
+export function percent(state: any): number {
+    const args: Arg[] = state?.args ?? [];
+    const [ a, b ] = args;
+
+    if (b === undefined || b === null) {
+        return op({ ...state, args: [ 'percent', a ] });
+    } else {
+        return op({ ...state, args: [ a, 'divide', b, 'multiply', 100 ] });
+    }
+}
+
+export function sqrt(state: any): number {
+    const args: Arg[] = state?.args ?? [];
+    const [ a ] = args;
+
+    return op({ ...state, args: [ 'sqrt', a ] });
+}
+
+export function cbrt(state: any): number {
+    const args: Arg[] = state?.args ?? [];
+    const [ a ] = args;
+
+    return op({ ...state, args: [ 'cbrt', a ] });
+}
+
+export function abs(state: any): number {
+    const args: Arg[] = state?.args ?? [];
+    const [ a ] = args;
+
+    return op({ ...state, args: [ 'abs', a ] });
+}
+
+
+export default defineModule({
+    helpers: {
+        op: op,
+        plus: plus,
+        sum: _sum,
+        minus: minus,
+        mul: multiply,
+        multiply: multiply,
+        div: divide,
+        divide: divide,
+        intDivide: intDivide,
+        pow: power,
+        power: power,
+        round: round,
+        sqrt: sqrt,
+        cbrt: cbrt,
+        abs: abs,
+        __default: op,
+    },
+});

package/src/modules/media/index.ts

@@ -0,0 +1,27 @@
+import { Obj } from '@/types';
+import { defineModule } from '@/lib';
+import { TemplateError } from '@/errors';
+
+
+// Functions
+
+export function url(state: any): string {
+    const flext: Obj = state?.flext ?? {};
+    const args: any[] = state?.args ?? [];
+    const [ name ] = args;
+    const assets = flext?.assets ?? {};
+    const asset = assets[name] ?? null;
+
+    if (asset)
+        return URL.createObjectURL(asset);
+    else
+        throw new TemplateError(`Media: Unable to get the asset: Asset '${name}' does not exist`);
+}
+
+
+export default defineModule({
+    helpers: {
+        url: url,
+        __default: url,
+    },
+});

package/src/modules/number/index.ts

@@ -0,0 +1,73 @@
+import { Obj } from '@/types';
+import { isNumber, defineModule } from '@/lib';
+import writtenNumber from 'written-number';
+import kkKz from './locales/kkKz.json';
+import localeNames from './localeNames.json';
+
+
+// Constants
+
+export const DEFAULT_LANG = 'en';
+
+export const LOCALES: Obj = {
+    'kk-KZ': kkKz,
+};
+
+
+// Functions
+
+export function op(state: any): number|string|boolean {
+    const flext: Obj = state?.flext ?? {};
+    const args: any[] = state?.args ?? [];
+    const namedArgs: Obj = state?.namedArgs ?? {};
+    const [ op, number ] = args;
+    const { lang, strict } = namedArgs;
+
+
+    // Defining the functions
+
+    const locale = (lang: string): string | Obj | null => {
+        return localeNames[lang] ?? LOCALES[lang] ?? null;
+    };
+
+
+    // Getting the locale
+
+    const newLang = locale(lang) ?? locale(flext?.lang) ?? DEFAULT_LANG;
+
+
+    // Applying the operation
+
+    switch (op) {
+        case 'text':
+            return writtenNumber(Number(number), { lang: newLang });
+        case 'check':
+            return strict ? typeof number === 'number' : isNumber(number);
+        default:
+            return Number(op);
+    }
+}
+
+export function text(state: any): string {
+    const args: any[] = state?.args ?? [];
+    const [ number ] = args;
+
+    return String(op({ ...state, args: [ 'text', number ] }));
+}
+
+export function check(state: any): boolean {
+    const args: any[] = state?.args ?? [];
+    const [ number ] = args;
+
+    return op({ ...state, args: [ 'check', number ] }) as boolean;
+}
+
+
+export default defineModule({
+    helpers: {
+        op: op,
+        text: text,
+        check: check,
+        __default: op,
+    },
+});

package/src/modules/number/localeNames.json

@@ -0,0 +1,16 @@
+{
+  "ar-EG": "ar",
+  "az-AZ": "az",
+  "en-IN": "enIndian",
+  "en-GB": "uk",
+  "en-US": "en",
+  "eo": "eo",
+  "es-ES": "es",
+  "fr-FR": "fr",
+  "id-ID": "id",
+  "pt-BR": "pt",
+  "pt-PT": "ptPT",
+  "ru-RU": "ru",
+  "tr-TR": "tr",
+  "vi-VN": "vi"
+}

package/src/modules/number/locales/kkKz.json

@@ -0,0 +1,98 @@
+{
+  "useLongScale": false,
+  "baseSeparator": " ",
+  "unitSeparator": " ",
+  "base": {
+    "0": "нөл",
+    "1": "бір",
+    "2": "екі",
+    "3": "үш",
+    "4": "төрт",
+    "5": "бес",
+    "6": "алты",
+    "7": "жеті",
+    "8": "сегіз",
+    "9": "тоғыз",
+    "10": "он",
+    "11": "он бір",
+    "12": "он екі",
+    "13": "он үш",
+    "14": "он төрт",
+    "15": "он бес",
+    "16": "он алты",
+    "17": "он жеті",
+    "18": "он сегіз",
+    "19": "он тоғыз",
+    "20": "жиырма",
+    "30": "отыз",
+    "40": "қырық",
+    "50": "елу",
+    "60": "алпыс",
+    "70": "жетпіс",
+    "80": "сексен",
+    "90": "тоқсан",
+    "100": "жүз",
+    "200": "екі жүз",
+    "300": "үш жүз",
+    "400": "төрт жүз",
+    "500": "бес жүз",
+    "600": "алты жүз",
+    "700": "жеті жүз",
+    "800": "сегіз жүз",
+    "900": "тоғыз жүз"
+  },
+  "alternativeBase": {},
+  "units": [
+    {
+      "useBaseInstead": true,
+      "useBaseException": []
+    },
+    {
+      "singular": "мың",
+      "plural": "мың"
+    },
+    {
+      "singular": "миллион",
+      "plural": "миллион"
+    },
+    {
+      "singular": "миллиард",
+      "plural": "миллиард"
+    },
+    {
+      "singular": "триллион",
+      "plural": "триллион"
+    },
+    {
+      "singular": "квадриллион",
+      "plural": "квадриллион"
+    },
+    {
+      "singular": "квинтиллион",
+      "plural": "квинтиллион"
+    },
+    {
+      "singular": "секстиллион",
+      "plural": "секстиллион"
+    },
+    {
+      "singular": "септиллион",
+      "plural": "септиллион"
+    },
+    {
+      "singular": "октиллион",
+      "plural": "октиллион"
+    },
+    {
+      "singular": "нониллион",
+      "plural": "нониллион"
+    },
+    {
+      "singular": "дециллион",
+      "plural": "дециллион"
+    }
+  ],
+  "unitExceptions": {
+    "1000": "мың"
+  }
+}

package/src/modules/put/index.ts

@@ -0,0 +1,41 @@
+import { SafeString } from 'handlebars';
+import { Obj } from '@/types';
+import { defineModule, isNumber, inarr, ensureDate } from '@/lib';
+import { format } from '../date';
+
+
+// Contents
+
+export const DEFAULT_COLOR = 'text-blue-500';
+
+
+// Functions
+
+export function put(state: any): string {
+    const args = state?.args ?? [];
+    const [ val, fallback ] = args;
+    const date = ensureDate(val, false);
+
+    if (date && !isNumber(val) && !inarr(val, true, false))
+        return format(date);
+    else
+        return val ?? fallback ?? '';
+}
+
+export function putWithColor(state: any): SafeString {
+    const namedArgs: Obj = state?.namedArgs ?? {};
+    const color = namedArgs?.color ?? DEFAULT_COLOR;
+
+    if (color)
+        return new SafeString(`<span class="${color}">${put(state)}</span>`);
+    else
+        return new SafeString(state);
+}
+
+
+export default defineModule({
+    helpers: {
+        noColor: put,
+        __default: putWithColor,
+    },
+});

package/src/modules/string/index.ts

@@ -0,0 +1,45 @@
+import { defineModule } from '@/lib';
+
+
+// Functions
+
+export function op(state: any): any[] | boolean {
+    const args: any[] = state?.args ?? [];
+    const [ op, str ] = args;
+
+
+    // Applying the operation
+
+    switch (op) {
+        case 'json':
+            return JSON.parse(str);
+        case 'check':
+            return typeof str === 'string';
+        default:
+            return op;
+    }
+}
+
+export function json(state: any): any[] {
+    const args: any[] = state?.args ?? [];
+    const [ str ] = args;
+
+    return op({ ...state, args: [ 'json', str ] }) as any[];
+}
+
+export function check(state: any): boolean {
+    const args: any[] = state?.args ?? [];
+    const [ str ] = args;
+
+    return op({ ...state, args: [ 'check', str ] }) as boolean;
+}
+
+
+export default defineModule({
+    helpers: {
+        op: op,
+        json: json,
+        check: check,
+        __default: op,
+    },
+});

package/src/tsconfig.json

@@ -0,0 +1,35 @@
+{
+  "compilerOptions": {
+    "baseUrl": "..",
+    "paths": {
+      "@/*": [ "src/*" ]
+    },
+    "target": "ES2020",
+    "useDefineForClassFields": true,
+    "module": "ESNext",
+    "lib": [ "ES2020", "DOM" ],
+    "types": [ "node" ],
+    "skipLibCheck": true,
+    "resolveJsonModule": true,
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+    "noImplicitAny": false,
+
+    /* Bundler mode */
+    "outDir": "../dist",
+    "moduleResolution": "node",
+    "isolatedModules": false,
+    "moduleDetection": "force",
+    "declaration": true,
+    "sourceMap": false,
+    "emitDeclarationOnly": true,
+
+    /* Linting */
+    "strict": true,
+    "strictNullChecks": false,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noFallthroughCasesInSwitch": true
+  },
+  "include": [ "**/*.ts", "**/*.d.ts" ]
+}

package/src/types.ts

@@ -0,0 +1,103 @@
+import { AST } from '@handlebars/parser';
+
+
+// Base Data Types
+
+export type Obj<T extends any = any> = Record<string, T>;
+
+export type Isset<T extends any> = T extends null|undefined ? false : true;
+
+export type IsNumber<T extends any> = T extends number ? true : false;
+
+export type IsObject<T extends any, O extends Obj = Obj> = T extends O ? true : false;
+
+export type Has<T extends Obj, K extends keyof T> = T[K];
+
+export type Inarr<T extends any, A extends any[]> = T extends A[any] ? true : false;
+
+export type FieldType = 'string' | 'number' | 'boolean' | 'object' | 'array' | 'date' | 'mixed';
+
+export type FieldValue = string | number | boolean | Obj | FieldValue[] | null;
+
+
+// Base Struct Types
+
+export type MacroParam = {
+    name: string,
+    value: string|null,
+};
+
+export type Macro = {
+    name: string,
+    params: MacroParam[],
+};
+
+export type FieldValueOption = {
+    type: string,
+    name: string,
+    fieldName: string,
+    label?: string|null,
+    descr?: string|null,
+    value?: FieldValue | null,
+    isDisabled: boolean,
+};
+
+export type Field = {
+    type: FieldType,
+    name: string,
+    label?: string|null,
+    descr?: string|null,
+    hint?: string|null,
+    min?: Date | number | null,
+    max?: Date | number | null,
+    minLength?: number|null,
+    maxLength?: number|null,
+    order?: number|null,
+    options?: FieldValueOption[] | null,
+    value?: FieldValue,
+    isRequired: boolean,
+    extra?: {
+        macroName?: string|null,
+        absoluteOrder?: number|null,
+    }
+};
+
+export type DataModelNode = {
+    name: string,
+    $?: DataModelNode[],
+};
+
+export type DataModel = DataModelNode & {
+    addPath: (path: string, depth?: number) => void,
+};
+
+export type MetadataModelNode = DataModelNode & {
+    type: FieldType,
+    label?: string|null,
+    descr?: string|null,
+    hint?: string|null,
+    min?: Date | number | null,
+    max?: Date | number | null,
+    minLength?: number|null,
+    maxLength?: number|null,
+    order?: number|null,
+    options?: FieldValueOption[] | null,
+    value?: string|null,
+    isRequired: boolean,
+    extra?: {
+        fieldName?: string|null,
+    },
+};
+
+
+// Base Callable Types
+
+export type CollectorFilterHandler<T = any> = (val?: T) => boolean;
+
+export type GetProcessedTemplateHandler = (val: string) => string;
+
+export type GetTemplateAstHandler = (val: string) => AST.Program;
+
+export type GetTemplateTitleHandler = (ast: AST.Program) => string[];
+
+export type GetTemplateMacroHandler = (ast: AST.Program) => Macro[];