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

package/src/expressions/funcs/dict.ts

@@ -1,6 +1,17 @@
 import { toBigInt } from '../bigint';
 import { ARRAY, BOOLEAN, COLOR, DICT, INTEGER, NUMBER, STRING, URL } from '../const';
-import type { ArrayValue, BooleanValue, DictValue, EvalContext, EvalTypes, EvalTypesWithoutDatetime, EvalValue, IntegerValue, NumberValue, StringValue } from '../eval';
+import type {
+    ArrayValue,
+    BooleanValue,
+    DictValue,
+    EvalContext,
+    EvalTypes,
+    EvalTypesWithoutDatetime,
+    EvalValue,
+    IntegerValue,
+    NumberValue,
+    StringValue
+} from '../eval';
 import { checkUrl, convertJsValueToDivKit, transformColorValue } from '../utils';
 import { registerFunc, registerMethod } from './funcs';
 
@@ -27,7 +38,10 @@ function dictGetter(evalType: EvalTypesWithoutDatetime) {
             throw new Error('Non empty argument list is required.');
         }
 
-        const val = getProp(dict.value, path.map(it => it.value));
+        const val = getProp(
+            dict.value,
+            path.map(it => it.value)
+        );
 
         return convertJsValueToDivKit(ctx, val, evalType);
     };

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
     };
 }