react-native-divkit 0.1.0-alpha.1

package/src/expressions/funcs/trigonometry.ts

@@ -0,0 +1,108 @@
+import type { EvalContext, EvalValue, NumberValue } from '../eval';
+import { registerFunc } from './funcs';
+import { NUMBER } from '../const';
+
+function pi(): EvalValue {
+    return {
+        type: NUMBER,
+        value: Math.PI
+    };
+}
+
+function toRadians(_ctx: EvalContext, degrees: NumberValue): EvalValue {
+    return {
+        type: NUMBER,
+        value: degrees.value / 180 * Math.PI
+    };
+}
+
+function toDegrees(_ctx: EvalContext, radians: NumberValue): EvalValue {
+    return {
+        type: NUMBER,
+        value: radians.value / Math.PI * 180
+    };
+}
+
+function sin(_ctx: EvalContext, rad: NumberValue): EvalValue {
+    return {
+        type: NUMBER,
+        value: Math.sin(rad.value)
+    };
+}
+
+function cos(_ctx: EvalContext, rad: NumberValue): EvalValue {
+    return {
+        type: NUMBER,
+        value: Math.cos(rad.value)
+    };
+}
+
+function tan(_ctx: EvalContext, rad: NumberValue): EvalValue {
+    return {
+        type: NUMBER,
+        value: Math.tan(rad.value)
+    };
+}
+
+function cot(_ctx: EvalContext, rad: NumberValue): EvalValue {
+    const tan = Math.tan(rad.value);
+
+    if (Math.abs(tan) < 1e-12) {
+        throw new Error('Cotangent is undefined for the given value.');
+    }
+
+    return {
+        type: NUMBER,
+        value: 1 / tan
+    };
+}
+
+function atan(_ctx: EvalContext, rad: NumberValue): EvalValue {
+    return {
+        type: NUMBER,
+        value: Math.atan(rad.value)
+    };
+}
+
+function atan2(_ctx: EvalContext, y: NumberValue, x: NumberValue): EvalValue {
+    return {
+        type: NUMBER,
+        value: Math.atan2(y.value, x.value)
+    };
+}
+
+function asin(_ctx: EvalContext, rad: NumberValue): EvalValue {
+    if (rad.value > 1 || rad.value < -1) {
+        throw new Error('Arcsine is undefined for the given value.');
+    }
+
+    return {
+        type: NUMBER,
+        value: Math.asin(rad.value)
+    };
+}
+
+function acos(_ctx: EvalContext, rad: NumberValue): EvalValue {
+    if (rad.value > 1 || rad.value < -1) {
+        throw new Error('Arccosine is undefined for the given value.');
+    }
+
+    return {
+        type: NUMBER,
+        value: Math.acos(rad.value)
+    };
+}
+
+export function registerTrigonometry(): void {
+    registerFunc('pi', [], pi);
+    registerFunc('toRadians', [NUMBER], toRadians);
+    registerFunc('toDegrees', [NUMBER], toDegrees);
+    registerFunc('sin', [NUMBER], sin);
+    registerFunc('cos', [NUMBER], cos);
+    registerFunc('tan', [NUMBER], tan);
+    registerFunc('cot', [NUMBER], cot);
+    registerFunc('atan', [NUMBER], atan);
+    registerFunc('atan2', [NUMBER, NUMBER], atan2);
+    registerFunc('asin', [NUMBER], asin);
+    registerFunc('acos', [NUMBER], acos);
+}

package/src/expressions/json.ts

@@ -0,0 +1,367 @@
+/* eslint-disable max-depth */
+import type { Node } from './ast';
+import type { Variable, VariableValue } from './variable';
+import type { Store } from '../../typings/store';
+import { uniq } from '../utils/uniq';
+import { parse } from './expressions';
+import { evalExpression, type VariablesMap } from './eval';
+import { dateToString, gatherVarsFromAst, stringifyColor } from './utils';
+import { type LogError, wrapError } from '../utils/wrapError';
+import { parseColor } from '../utils/correctColor';
+import { MAX_INT32, MIN_INT32 } from './const';
+import { simpleUnescapeString } from './simpleUnescapeString';
+import { cacheGet, cacheSet } from './parserCache';
+import type { CustomFunctions } from './funcs/customFuncs';
+
+class ExpressionBinding {
+    private readonly ast: Node;
+    private readonly expr: string;
+
+    constructor(ast: Node, expr: string) {
+        this.ast = ast;
+        this.expr = expr;
+    }
+
+    /**
+     * Applies variables into ast
+     * @param variables
+     * @param logError
+     */
+    apply<T>(
+        {
+            variables,
+            customFunctions,
+            logError,
+            store,
+            weekStartDay,
+            keepComplex
+        }: {
+            variables: VariablesMap;
+            customFunctions: CustomFunctions | undefined;
+            logError: LogError;
+            store: Store | undefined;
+            weekStartDay: number;
+            keepComplex?: boolean;
+        }
+    ): {
+        result: T;
+        usedVars?: Set<Variable>;
+    } {
+        let res: ReturnType<typeof evalExpression> | undefined;
+
+        try {
+            res = evalExpression(variables, customFunctions, store, this.ast, {
+                weekStartDay
+            });
+            res.warnings.forEach(logError);
+            const result = res.result;
+
+            if (result.type === 'error') {
+                logError(wrapError(new Error('Expression execution error'), {
+                    additional: {
+                        message: result.value,
+                        expression: this.expr
+                    }
+                }));
+                return {
+                    result: undefined as T,
+                    usedVars: res.usedVars
+                };
+            }
+
+            const value = result.value;
+            if (value instanceof Date) {
+                return {
+                    result: dateToString(value) as T,
+                    usedVars: res.usedVars
+                };
+            }
+            if (result.type === 'boolean') {
+                return {
+                    result: Boolean(value) as T,
+                    usedVars: res.usedVars
+                };
+            }
+            if (result.type === 'color') {
+                const parsed = parseColor(String(value));
+                if (parsed) {
+                    return {
+                        result: stringifyColor(parsed) as T,
+                        usedVars: res.usedVars
+                    };
+                }
+                logError(wrapError(new Error('Expression execution error')));
+            }
+            if (result.type === 'integer') {
+                if ((value as number) > MAX_INT32 || (value as number) < MIN_INT32) {
+                    logError(wrapError(new Error('Expression result is out of 32-bit int range')));
+                    return {
+                        result: undefined as T,
+                        usedVars: res.usedVars
+                    };
+                }
+                return {
+                    result: Number(value) as T,
+                    usedVars: res.usedVars
+                };
+            }
+            if (result.type === 'function') {
+                return {
+                    result: `<${result.value[0]?.name || 'Function'}>` as T,
+                    usedVars: res.usedVars
+                };
+            }
+            if (!keepComplex && (result.type === 'array' || result.type === 'dict')) {
+                try {
+                    return {
+                        result: JSON.stringify(value) as T,
+                        usedVars: res.usedVars
+                    };
+                } catch (err) {
+                    logError(wrapError(new Error(`Failed to stringify ${result.type}`)));
+                    return {
+                        result: `<${result.type}>` as T,
+                        usedVars: res.usedVars
+                    };
+                }
+            }
+            return {
+                result: value as T,
+                usedVars: res.usedVars
+            };
+        } catch (err) {
+            logError(wrapError(new Error('Expression execution error'), {
+                additional: {
+                    expression: this.expr
+                }
+            }));
+            return {
+                result: undefined as T,
+                usedVars: res?.usedVars
+            };
+        }
+    }
+}
+
+class VariableBinding {
+    private readonly variable: string;
+
+    constructor(variable: string) {
+        this.variable = variable;
+    }
+
+    /**
+     * Applies variables into ast
+     * @param variables
+     * @param logError
+     */
+    apply(variables: VariablesMap): VariableValue | string | undefined {
+        const varInstance = variables.get(this.variable);
+        if (varInstance) {
+            return varInstance.getValue();
+        }
+
+        return undefined;
+    }
+}
+
+export type MaybeMissing<T> = T | (
+    T extends (infer U)[] ?
+        MaybeMissing<U>[] :
+        (
+            T extends object ?
+                {
+                    [P in keyof T]?: MaybeMissing<T[P]>;
+                } :
+                T | undefined
+        )
+);
+
+function hasExpressions(str: string): boolean {
+    return str.indexOf('@{') > -1 || str.indexOf('\\') > -1;
+}
+
+function prepareVarsObj<T>(
+    jsonProp: T,
+    store: {
+        vars: string[];
+        hasExpression: boolean;
+    },
+    logError: LogError,
+    maxDepth: number
+): unknown {
+    if (jsonProp) {
+        if (typeof jsonProp === 'string') {
+            if (hasExpressions(jsonProp)) {
+                store.hasExpression = true;
+
+                if (process.env.ENABLE_EXPRESSIONS || process.env.ENABLE_EXPRESSIONS === undefined) {
+                    try {
+                        const ast = cacheGet(jsonProp) || parse(jsonProp, {
+                            startRule: 'JsonStringContents'
+                        });
+                        cacheSet(jsonProp, ast);
+                        const propVars = gatherVarsFromAst(ast);
+                        store.vars.push(...propVars);
+
+                        return new ExpressionBinding(ast, jsonProp);
+                    } catch (err) {
+                        logError(wrapError(new Error('Unable to parse expression'), {
+                            additional: {
+                                expression: jsonProp
+                            }
+                        }));
+                        return undefined;
+                    }
+                } else {
+                    if (jsonProp === '@{}') {
+                        return '';
+                    } else if (jsonProp.startsWith('@{') && jsonProp.endsWith('}')) {
+                        return new VariableBinding(jsonProp.substring(2, jsonProp.length - 1));
+                    }
+                    try {
+                        return simpleUnescapeString(jsonProp);
+                    } catch (err: any) {
+                        logError(wrapError(err as Error, {
+                            additional: {
+                                expression: jsonProp
+                            }
+                        }));
+                        return undefined;
+                    }
+                }
+            }
+        } else if (Array.isArray(jsonProp) && maxDepth > 0) {
+            return jsonProp.map(item => prepareVarsObj(item, store, logError, maxDepth - 1));
+        } else if (typeof jsonProp === 'object' && maxDepth > 0) {
+            const res: Record<string, unknown> = {};
+            for (const key in jsonProp) {
+                res[key] = prepareVarsObj(jsonProp[key], store, logError, maxDepth - 1);
+            }
+            return res;
+        }
+    }
+    return jsonProp;
+}
+
+function applyVars<T>(
+    jsonProp: T,
+    opts: {
+        variables: VariablesMap;
+        customFunctions: CustomFunctions | undefined;
+        logError: LogError;
+        store: Store | undefined;
+        weekStartDay: number;
+        keepComplex?: boolean;
+    }
+): {
+    result: MaybeMissing<T>;
+    usedVars?: Set<Variable>;
+} {
+    if (jsonProp) {
+        if (
+            (process.env.ENABLE_EXPRESSIONS || process.env.ENABLE_EXPRESSIONS === undefined) &&
+            jsonProp instanceof ExpressionBinding
+        ) {
+            return jsonProp.apply<T>(opts);
+        } else if (
+            (!process.env.ENABLE_EXPRESSIONS && process.env.ENABLE_EXPRESSIONS !== undefined) &&
+            jsonProp instanceof VariableBinding
+        ) {
+            return {
+                result: jsonProp.apply(opts.variables) as T
+            };
+        } else if (Array.isArray(jsonProp)) {
+            let usedVars: Set<Variable> | undefined;
+            const arr = jsonProp.map(it => {
+                const subres = applyVars(it, opts);
+
+                if (subres.usedVars) {
+                    if (!usedVars) {
+                        usedVars = new Set();
+                    }
+                    for (const instance of subres.usedVars) {
+                        usedVars.add(instance);
+                    }
+                }
+
+                return subres.result;
+            });
+
+            return {
+                result: arr as MaybeMissing<T>,
+                usedVars
+            };
+        } else if (typeof jsonProp === 'object') {
+            const res: Record<string, unknown> = {};
+            let usedVars: Set<Variable> | undefined;
+            for (const key in jsonProp) {
+                const subres = applyVars(jsonProp[key as keyof typeof jsonProp], opts);
+                res[key] = subres.result;
+
+                if (subres.usedVars) {
+                    if (!usedVars) {
+                        usedVars = new Set();
+                    }
+                    for (const instance of subres.usedVars) {
+                        usedVars.add(instance);
+                    }
+                }
+            }
+            return {
+                result: res as MaybeMissing<T>,
+                usedVars
+            };
+        }
+    }
+    return {
+        result: jsonProp
+    };
+}
+
+export interface PreparedExpression<T> {
+    vars: string[];
+    hasExpression: boolean;
+    applyVars: (
+        variables: VariablesMap,
+        customFunctions?: CustomFunctions,
+        keepComplex?: boolean
+    ) => {
+        result: MaybeMissing<T>;
+        usedVars?: Set<Variable>;
+    };
+}
+
+export function prepareVars<T>(
+    jsonProp: T,
+    logError: LogError,
+    store: Store | undefined,
+    weekStartDay: number,
+    maxDepth = Infinity
+): PreparedExpression<T> {
+    const result: {
+        vars: string[];
+        hasExpression: boolean;
+    } = {
+        vars: [],
+        hasExpression: false
+    };
+    const root = prepareVarsObj(jsonProp, result, logError, maxDepth);
+
+    const vars = uniq(result.vars);
+
+    return {
+        vars,
+        hasExpression: result.hasExpression,
+        applyVars(variables, customFunctions, keepComplex) {
+            return applyVars<T>(root as T, {
+                variables,
+                customFunctions,
+                logError,
+                store,
+                weekStartDay,
+                keepComplex
+            });
+        }
+    };
+}

package/src/expressions/parserCache.ts

@@ -0,0 +1,32 @@
+import type { Node } from './ast';
+
+/**
+ * LRU cache
+ * JavaScript Map iteration is guaranteed to be performed in the insertation order
+ * On usage, remove the item from the Map and insert it in the end
+ */
+
+const MAX_ENTRIES = 128;
+
+const cache = new Map();
+let latestItem: string | undefined;
+
+export function cacheGet(expr: string): Node | undefined {
+    return cache.get(expr);
+}
+
+export function cacheSet(expr: string, ast: Node): void {
+    if (expr === latestItem) {
+        return;
+    }
+
+    cache.delete(expr);
+
+    if (cache.size >= MAX_ENTRIES) {
+        cache.delete(cache.keys().next().value);
+    }
+
+    cache.set(expr, ast);
+
+    latestItem = expr;
+}

package/src/expressions/simpleUnescapeString.ts

@@ -0,0 +1,57 @@
+export function simpleUnescapeString(str: string): string {
+    let res = '';
+    let isAt = false;
+    let isBackslash = false;
+
+    for (let i = 0; i < str.length; ++i) {
+        const char = str.charAt(i);
+        if (char === '\\') {
+            if (isAt) {
+                isAt = false;
+                res += '@';
+            }
+            if (isBackslash) {
+                res += char;
+                isBackslash = false;
+            } else {
+                isBackslash = true;
+            }
+        } else if (char === '@') {
+            if (isBackslash) {
+                res += char;
+            } else if (isAt) {
+                res += char;
+            } else {
+                isAt = true;
+            }
+        } else if (char === '{') {
+            if (isAt) {
+                throw new Error('Expressions is not supported');
+            } else {
+                res += char;
+            }
+        } else {
+            if (isBackslash) {
+                throw new Error('Incorrect escape');
+            }
+            if (isAt) {
+                isAt = false;
+                res += '@';
+            }
+            res += char;
+        }
+
+        if (isBackslash && char !== '\\') {
+            isBackslash = false;
+        }
+    }
+
+    if (isAt) {
+        res += '@';
+    }
+    if (isBackslash) {
+        throw new Error('Incorrect escape');
+    }
+
+    return res;
+}