react-native-divkit 0.1.0-alpha.1 → 0.1.0-alpha.3

package/src/expressions/funcs/funcs.ts

@@ -3,10 +3,12 @@ import type { EvalTypes, EvalValue } from '../eval';
 import type { EvalContext } from '../eval';
 import { integerToNumber } from '../utils';
 
-export type FuncArg = EvalTypes | {
-    type: EvalTypes;
-    isVararg?: boolean;
-}
+export type FuncArg =
+    | EvalTypes
+    | {
+          type: EvalTypes;
+          isVararg?: boolean;
+      };
 
 export interface Func {
     name?: string;
@@ -19,27 +21,31 @@ export const funcByArgs: Map<string, Func> = new Map();
 export const methods: Map<string, Func[]> = new Map();
 export const methodByArgs: Map<string, Func> = new Map();
 
-export type FuncMatchError = {
-    type: 'mismatch';
-    expected: EvalTypes;
-    found: EvalTypes;
-    def: Func;
-    hasOverloads: boolean;
-} | {
-    type: 'few';
-    expected: number;
-    found: number;
-    def: Func;
-    hasOverloads: boolean;
-} | {
-    type: 'many';
-    expected: number;
-    found: number;
-    def: Func;
-    hasOverloads: boolean;
-} | {
-    type: 'missing';
-};
+export type FuncMatchError =
+    | {
+          type: 'mismatch';
+          expected: EvalTypes;
+          found: EvalTypes;
+          def: Func;
+          hasOverloads: boolean;
+      }
+    | {
+          type: 'few';
+          expected: number;
+          found: number;
+          def: Func;
+          hasOverloads: boolean;
+      }
+    | {
+          type: 'many';
+          expected: number;
+          found: number;
+          def: Func;
+          hasOverloads: boolean;
+      }
+    | {
+          type: 'missing';
+      };
 
 export interface FuncMatchFound {
     func: Func;
@@ -51,35 +57,19 @@ export type FuncMatch = FuncMatchFound | FuncMatchError;
 // no args
 export function registerFunc(name: string, args: [], cb: (ctx?: EvalContext) => EvalValue): void;
 // one specific arg
-export function registerFunc<
-    A0 extends EvalTypes
->(
+export function registerFunc<A0 extends EvalTypes>(
     name: string,
     args: [A0],
-    cb: (
-        ctx: EvalContext,
-        arg0: Extract<EvalValue, { type: A0 }>
-    ) => EvalValue
+    cb: (ctx: EvalContext, arg0: Extract<EvalValue, { type: A0 }>) => EvalValue
 ): void;
 // two specific args
-export function registerFunc<
-    A0 extends EvalTypes,
-    A1 extends EvalTypes
->(
+export function registerFunc<A0 extends EvalTypes, A1 extends EvalTypes>(
     name: string,
     args: [A0, A1],
-    cb: (
-        ctx: EvalContext,
-        arg0: Extract<EvalValue, { type: A0 }>,
-        arg1: Extract<EvalValue, { type: A1 }>
-    ) => EvalValue
+    cb: (ctx: EvalContext, arg0: Extract<EvalValue, { type: A0 }>, arg1: Extract<EvalValue, { type: A1 }>) => EvalValue
 ): void;
 // three specific args
-export function registerFunc<
-    A0 extends EvalTypes,
-    A1 extends EvalTypes,
-    A2 extends EvalTypes
->(
+export function registerFunc<A0 extends EvalTypes, A1 extends EvalTypes, A2 extends EvalTypes>(
     name: string,
     args: [A0, A1, A2],
     cb: (
@@ -90,11 +80,7 @@ export function registerFunc<
     ) => EvalValue
 ): void;
 // any args
-export function registerFunc(
-    name: string,
-    args: FuncArg[],
-    cb: (ctx: EvalContext, ...args: any[]) => EvalValue
-): void;
+export function registerFunc(name: string, args: FuncArg[], cb: (ctx: EvalContext, ...args: any[]) => EvalValue): void;
 
 export function registerFunc(
     name: string,
@@ -113,12 +99,17 @@ export function registerFunc(
     }
     arr.push(desc);
 
-    const funcKey = name + ':' + args.map(it => {
-        if (typeof it === 'object') {
-            return it.type;
-        }
-        return it;
-    }).join('#');
+    const funcKey =
+        name +
+        ':' +
+        args
+            .map(it => {
+                if (typeof it === 'object') {
+                    return it.type;
+                }
+                return it;
+            })
+            .join('#');
 
     funcByArgs.set(funcKey, desc);
 }
@@ -126,35 +117,19 @@ export function registerFunc(
 // no args
 export function registerMethod(name: string, args: [], cb: (ctx?: EvalContext) => EvalValue): void;
 // one specific arg
-export function registerMethod<
-    A0 extends EvalTypes
->(
+export function registerMethod<A0 extends EvalTypes>(
     name: string,
     args: [A0],
-    cb: (
-        ctx: EvalContext,
-        arg0: Extract<EvalValue, { type: A0 }>
-    ) => EvalValue
+    cb: (ctx: EvalContext, arg0: Extract<EvalValue, { type: A0 }>) => EvalValue
 ): void;
 // two specific args
-export function registerMethod<
-    A0 extends EvalTypes,
-    A1 extends EvalTypes
->(
+export function registerMethod<A0 extends EvalTypes, A1 extends EvalTypes>(
     name: string,
     args: [A0, A1],
-    cb: (
-        ctx: EvalContext,
-        arg0: Extract<EvalValue, { type: A0 }>,
-        arg1: Extract<EvalValue, { type: A1 }>
-    ) => EvalValue
+    cb: (ctx: EvalContext, arg0: Extract<EvalValue, { type: A0 }>, arg1: Extract<EvalValue, { type: A1 }>) => EvalValue
 ): void;
 // three specific args
-export function registerMethod<
-    A0 extends EvalTypes,
-    A1 extends EvalTypes,
-    A2 extends EvalTypes
->(
+export function registerMethod<A0 extends EvalTypes, A1 extends EvalTypes, A2 extends EvalTypes>(
     name: string,
     args: [A0, A1, A2],
     cb: (
@@ -188,20 +163,31 @@ export function registerMethod(
     }
     arr.push(desc);
 
-    const funcKey = name + ':' + args.map(it => {
-        if (typeof it === 'object') {
-            return it.type;
-        }
-        return it;
-    }).join('#');
+    const funcKey =
+        name +
+        ':' +
+        args
+            .map(it => {
+                if (typeof it === 'object') {
+                    return it.type;
+                }
+                return it;
+            })
+            .join('#');
 
     methodByArgs.set(funcKey, desc);
 }
 
-function matchFuncArgs(func: Func, args: EvalValue[], hasOverloads: boolean): {
-    type: 'match';
-    conversions: number;
-} | FuncMatchError {
+function matchFuncArgs(
+    func: Func,
+    args: EvalValue[],
+    hasOverloads: boolean
+):
+    | {
+          type: 'match';
+          conversions: number;
+      }
+    | FuncMatchError {
     const minArgs = func.args.length;
     let maxArgs = func.args.length;
     let conversions = 0;
@@ -319,5 +305,5 @@ export function convertArgs(func: Func, args: EvalValue[]): EvalValue[] {
 }
 
 export function funcToKey(funcName: string, func: Func): string {
-    return funcName + ':' + func.args.map(arg => typeof arg === 'string' ? arg : arg.type).join('#');
+    return funcName + ':' + func.args.map(arg => (typeof arg === 'string' ? arg : arg.type)).join('#');
 }

package/src/expressions/funcs/math.ts

@@ -329,53 +329,113 @@ export function registerMath(): void {
     registerFunc('mod', [INTEGER, INTEGER], modInteger);
     registerFunc('mod', [NUMBER, NUMBER], modNumber);
 
-    registerFunc('mul', [{
-        type: INTEGER,
-        isVararg: true
-    }], mulInteger);
-    registerFunc('mul', [{
-        type: NUMBER,
-        isVararg: true
-    }], mulNumber);
-
-    registerFunc('sub', [{
-        type: INTEGER,
-        isVararg: true
-    }], subInteger);
-    registerFunc('sub', [{
-        type: NUMBER,
-        isVararg: true
-    }], subNumber);
-
-    registerFunc('sum', [{
-        type: INTEGER,
-        isVararg: true
-    }], sumInteger);
-    registerFunc('sum', [{
-        type: NUMBER,
-        isVararg: true
-    }], sumNumber);
+    registerFunc(
+        'mul',
+        [
+            {
+                type: INTEGER,
+                isVararg: true
+            }
+        ],
+        mulInteger
+    );
+    registerFunc(
+        'mul',
+        [
+            {
+                type: NUMBER,
+                isVararg: true
+            }
+        ],
+        mulNumber
+    );
+
+    registerFunc(
+        'sub',
+        [
+            {
+                type: INTEGER,
+                isVararg: true
+            }
+        ],
+        subInteger
+    );
+    registerFunc(
+        'sub',
+        [
+            {
+                type: NUMBER,
+                isVararg: true
+            }
+        ],
+        subNumber
+    );
+
+    registerFunc(
+        'sum',
+        [
+            {
+                type: INTEGER,
+                isVararg: true
+            }
+        ],
+        sumInteger
+    );
+    registerFunc(
+        'sum',
+        [
+            {
+                type: NUMBER,
+                isVararg: true
+            }
+        ],
+        sumNumber
+    );
 
     registerFunc('abs', [INTEGER], absInteger);
     registerFunc('abs', [NUMBER], absNumber);
 
-    registerFunc('max', [{
-        type: INTEGER,
-        isVararg: true
-    }], maxInt);
-    registerFunc('max', [{
-        type: NUMBER,
-        isVararg: true
-    }], maxNum);
-
-    registerFunc('min', [{
-        type: INTEGER,
-        isVararg: true
-    }], minInt);
-    registerFunc('min', [{
-        type: NUMBER,
-        isVararg: true
-    }], minNum);
+    registerFunc(
+        'max',
+        [
+            {
+                type: INTEGER,
+                isVararg: true
+            }
+        ],
+        maxInt
+    );
+    registerFunc(
+        'max',
+        [
+            {
+                type: NUMBER,
+                isVararg: true
+            }
+        ],
+        maxNum
+    );
+
+    registerFunc(
+        'min',
+        [
+            {
+                type: INTEGER,
+                isVararg: true
+            }
+        ],
+        minInt
+    );
+    registerFunc(
+        'min',
+        [
+            {
+                type: NUMBER,
+                isVararg: true
+            }
+        ],
+        minNum
+    );
 
     registerFunc('maxNumber', [], maxNumber);
     registerFunc('minNumber', [], minNumber);

package/src/expressions/funcs/std.ts

@@ -26,7 +26,6 @@ function toString(
     };
 }
 
-
 function toNumber(_ctx: EvalContext, arg: IntegerValue | StringValue): EvalValue {
     const num = Number(arg.value);
 
@@ -43,7 +42,6 @@ function toNumber(_ctx: EvalContext, arg: IntegerValue | StringValue): EvalValue
     };
 }
 
-
 function toIntegerNumber(_ctx: EvalContext, arg: NumberValue): EvalValue {
     if (arg.value > MAX_INT || arg.value < MIN_INT) {
         throw new Error('Unable to convert value to Integer.');
@@ -79,7 +77,6 @@ function toIntegerBoolean(_ctx: EvalContext, arg: BooleanValue): EvalValue {
     };
 }
 
-
 function toBooleanInteger(_ctx: EvalContext, arg: IntegerValue): EvalValue {
     const intVal = Number(arg.value);
     if (intVal !== 1 && intVal !== 0) {
@@ -250,10 +247,10 @@ function decimalFormat(
     const pattern = format.value;
     const patternWithoutGroupping = pattern.replace(/,/g, '');
     if (
-        !/^((#+)|(#*0+))(\.0*#*)?$/.test(patternWithoutGroupping) &&
-        !/^#*0*\.((0*#*)|(#+))$/.test(patternWithoutGroupping) ||
+        (!/^((#+)|(#*0+))(\.0*#*)?$/.test(patternWithoutGroupping) &&
+            !/^#*0*\.((0*#*)|(#+))$/.test(patternWithoutGroupping)) ||
         /,.*,/.test(pattern) ||
-        pattern.indexOf(',') > pattern.indexOf('.') && pattern.indexOf('.') > -1
+        (pattern.indexOf(',') > pattern.indexOf('.') && pattern.indexOf('.') > -1)
     ) {
         throw new Error('Incorrect format pattern.');
     }
@@ -269,7 +266,7 @@ function decimalFormat(
     const groupIndex = rawInteger.indexOf(',');
     const digitsInGroup = groupIndex > -1 ? rawInteger.length - groupIndex - 1 : -1;
 
-    if (groupIndex > -1 && digitsInGroup < 1 || rawFraction.indexOf(',') > -1) {
+    if ((groupIndex > -1 && digitsInGroup < 1) || rawFraction.indexOf(',') > -1) {
         throw new Error('Incorrect format pattern.');
     }
 

package/src/expressions/funcs/strings.ts

@@ -25,10 +25,7 @@ function substring(_ctx: EvalContext, str: StringValue, start: IntegerValue, end
         throw new Error('Indexes should be in ascending order.');
     }
 
-    if (
-        start.value < 0 || start.value > str.value.length ||
-        end.value < 0 || end.value > str.value.length
-    ) {
+    if (start.value < 0 || start.value > str.value.length || end.value < 0 || end.value > str.value.length) {
         throw new Error('Indexes are out of bounds.');
     }
 
@@ -103,16 +100,13 @@ function toLowerCase(_ctx: EvalContext, str: StringValue): EvalValue {
     };
 }
 
-function calcPad(
-    ctx: EvalContext,
-    val: StringValue | IntegerValue,
-    len: IntegerValue,
-    pad: StringValue
-): string {
+function calcPad(ctx: EvalContext, val: StringValue | IntegerValue, len: IntegerValue, pad: StringValue): string {
     if (!pad.value.length) {
-        ctx.warnings.push(wrapError(new Error('String for padding is empty.'), {
-            level: 'warn'
-        }));
+        ctx.warnings.push(
+            wrapError(new Error('String for padding is empty.'), {
+                level: 'warn'
+            })
+        );
         return '';
     }
 
@@ -129,12 +123,7 @@ function calcPad(
     return part;
 }
 
-function padStart(
-    ctx: EvalContext,
-    val: StringValue | IntegerValue,
-    len: IntegerValue,
-    pad: StringValue
-): EvalValue {
+function padStart(ctx: EvalContext, val: StringValue | IntegerValue, len: IntegerValue, pad: StringValue): EvalValue {
     const prefix = calcPad(ctx, val, len, pad);
 
     return {
@@ -143,12 +132,7 @@ function padStart(
     };
 }
 
-function padEnd(
-    ctx: EvalContext,
-    val: StringValue | IntegerValue,
-    len: IntegerValue,
-    pad: StringValue
-): EvalValue {
+function padEnd(ctx: EvalContext, val: StringValue | IntegerValue, len: IntegerValue, pad: StringValue): EvalValue {
     const suffix = calcPad(ctx, val, len, pad);
 
     return {

package/src/expressions/funcs/trigonometry.ts

@@ -12,14 +12,14 @@ function pi(): EvalValue {
 function toRadians(_ctx: EvalContext, degrees: NumberValue): EvalValue {
     return {
         type: NUMBER,
-        value: degrees.value / 180 * Math.PI
+        value: (degrees.value / 180) * Math.PI
     };
 }
 
 function toDegrees(_ctx: EvalContext, radians: NumberValue): EvalValue {
     return {
         type: NUMBER,
-        value: radians.value / Math.PI * 180
+        value: (radians.value / Math.PI) * 180
     };
 }
 

package/src/expressions/json.ts

@@ -27,23 +27,21 @@ class ExpressionBinding {
      * @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;
-        }
-    ): {
+    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>;
     } {
@@ -57,12 +55,14 @@ class ExpressionBinding {
             const result = res.result;
 
             if (result.type === 'error') {
-                logError(wrapError(new Error('Expression execution error'), {
-                    additional: {
-                        message: result.value,
-                        expression: this.expr
-                    }
-                }));
+                logError(
+                    wrapError(new Error('Expression execution error'), {
+                        additional: {
+                            message: result.value,
+                            expression: this.expr
+                        }
+                    })
+                );
                 return {
                     result: undefined as T,
                     usedVars: res.usedVars
@@ -130,11 +130,13 @@ class ExpressionBinding {
                 usedVars: res.usedVars
             };
         } catch (err) {
-            logError(wrapError(new Error('Expression execution error'), {
-                additional: {
-                    expression: this.expr
-                }
-            }));
+            logError(
+                wrapError(new Error('Expression execution error'), {
+                    additional: {
+                        expression: this.expr
+                    }
+                })
+            );
             return {
                 result: undefined as T,
                 usedVars: res?.usedVars
@@ -165,17 +167,15 @@ class VariableBinding {
     }
 }
 
-export type MaybeMissing<T> = T | (
-    T extends (infer U)[] ?
-        MaybeMissing<U>[] :
-        (
-            T extends object ?
-                {
-                    [P in keyof T]?: MaybeMissing<T[P]>;
-                } :
-                T | 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;
@@ -197,20 +197,24 @@ function prepareVarsObj<T>(
 
                 if (process.env.ENABLE_EXPRESSIONS || process.env.ENABLE_EXPRESSIONS === undefined) {
                     try {
-                        const ast = cacheGet(jsonProp) || parse(jsonProp, {
-                            startRule: 'JsonStringContents'
-                        });
+                        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
-                            }
-                        }));
+                        logError(
+                            wrapError(new Error('Unable to parse expression'), {
+                                additional: {
+                                    expression: jsonProp
+                                }
+                            })
+                        );
                         return undefined;
                     }
                 } else {
@@ -222,11 +226,13 @@ function prepareVarsObj<T>(
                     try {
                         return simpleUnescapeString(jsonProp);
                     } catch (err: any) {
-                        logError(wrapError(err as Error, {
-                            additional: {
-                                expression: jsonProp
-                            }
-                        }));
+                        logError(
+                            wrapError(err as Error, {
+                                additional: {
+                                    expression: jsonProp
+                                }
+                            })
+                        );
                         return undefined;
                     }
                 }
@@ -265,7 +271,8 @@ function applyVars<T>(
         ) {
             return jsonProp.apply<T>(opts);
         } else if (
-            (!process.env.ENABLE_EXPRESSIONS && process.env.ENABLE_EXPRESSIONS !== undefined) &&
+            !process.env.ENABLE_EXPRESSIONS &&
+            process.env.ENABLE_EXPRESSIONS !== undefined &&
             jsonProp instanceof VariableBinding
         ) {
             return {