react-native-divkit 0.1.0-alpha.1

package/src/expressions/funcs/funcs.ts

@@ -0,0 +1,323 @@
+import { INTEGER, NUMBER } from '../const';
+import type { EvalTypes, EvalValue } from '../eval';
+import type { EvalContext } from '../eval';
+import { integerToNumber } from '../utils';
+
+export type FuncArg = EvalTypes | {
+    type: EvalTypes;
+    isVararg?: boolean;
+}
+
+export interface Func {
+    name?: string;
+    args: FuncArg[];
+    cb(ctx: EvalContext, ...args: EvalValue[]): EvalValue;
+}
+
+export const funcs: Map<string, Func[]> = new Map();
+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 interface FuncMatchFound {
+    func: Func;
+    conversions: number;
+}
+
+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
+>(
+    name: string,
+    args: [A0],
+    cb: (
+        ctx: EvalContext,
+        arg0: Extract<EvalValue, { type: A0 }>
+    ) => EvalValue
+): void;
+// two specific args
+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
+): void;
+// three specific args
+export function registerFunc<
+    A0 extends EvalTypes,
+    A1 extends EvalTypes,
+    A2 extends EvalTypes
+>(
+    name: string,
+    args: [A0, A1, A2],
+    cb: (
+        ctx: EvalContext,
+        arg0: Extract<EvalValue, { type: A0 }>,
+        arg1: Extract<EvalValue, { type: A1 }>,
+        arg2: Extract<EvalValue, { type: A2 }>
+    ) => 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: EvalValue[]) => EvalValue
+): void {
+    const desc: Func = {
+        args,
+        cb
+    };
+
+    const arr = funcs.get(name) || [];
+
+    if (!funcs.has(name)) {
+        funcs.set(name, arr);
+    }
+    arr.push(desc);
+
+    const funcKey = name + ':' + args.map(it => {
+        if (typeof it === 'object') {
+            return it.type;
+        }
+        return it;
+    }).join('#');
+
+    funcByArgs.set(funcKey, desc);
+}
+
+// no args
+export function registerMethod(name: string, args: [], cb: (ctx?: EvalContext) => EvalValue): void;
+// one specific arg
+export function registerMethod<
+    A0 extends EvalTypes
+>(
+    name: string,
+    args: [A0],
+    cb: (
+        ctx: EvalContext,
+        arg0: Extract<EvalValue, { type: A0 }>
+    ) => EvalValue
+): void;
+// two specific args
+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
+): void;
+// three specific args
+export function registerMethod<
+    A0 extends EvalTypes,
+    A1 extends EvalTypes,
+    A2 extends EvalTypes
+>(
+    name: string,
+    args: [A0, A1, A2],
+    cb: (
+        ctx: EvalContext,
+        arg0: Extract<EvalValue, { type: A0 }>,
+        arg1: Extract<EvalValue, { type: A1 }>,
+        arg2: Extract<EvalValue, { type: A2 }>
+    ) => EvalValue
+): void;
+// any args
+export function registerMethod(
+    name: string,
+    args: FuncArg[],
+    cb: (ctx: EvalContext, ...args: any[]) => EvalValue
+): void;
+
+export function registerMethod(
+    name: string,
+    args: FuncArg[],
+    cb: (ctx: EvalContext, ...args: EvalValue[]) => EvalValue
+): void {
+    const desc: Func = {
+        args,
+        cb
+    };
+
+    const arr = methods.get(name) || [];
+
+    if (!methods.has(name)) {
+        methods.set(name, arr);
+    }
+    arr.push(desc);
+
+    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 {
+    const minArgs = func.args.length;
+    let maxArgs = func.args.length;
+    let conversions = 0;
+    const lastArg = func.args[func.args.length - 1];
+
+    if (typeof lastArg === 'object' && lastArg.isVararg) {
+        maxArgs = Infinity;
+    }
+
+    if (args.length < minArgs) {
+        return {
+            type: 'few',
+            expected: minArgs,
+            found: args.length,
+            def: func,
+            hasOverloads
+        };
+    } else if (args.length > maxArgs) {
+        return {
+            type: 'many',
+            expected: maxArgs,
+            found: args.length,
+            def: func,
+            hasOverloads
+        };
+    }
+
+    for (let i = 0; i < args.length; ++i) {
+        let funcArg = i >= func.args.length ? func.args[func.args.length - 1] : func.args[i];
+        if (typeof funcArg !== 'object') {
+            funcArg = {
+                type: funcArg
+            };
+        }
+
+        if (funcArg.type === NUMBER && args[i].type === INTEGER) {
+            ++conversions;
+            continue;
+        }
+
+        if (funcArg.type !== args[i].type) {
+            return {
+                type: 'mismatch',
+                expected: funcArg.type,
+                found: args[i].type,
+                def: func,
+                hasOverloads
+            };
+        }
+    }
+
+    return {
+        type: 'match',
+        conversions
+    };
+}
+
+export function findBestMatchedFuncList(list: Func[] | undefined, args: EvalValue[]): FuncMatch {
+    if (!list) {
+        return {
+            type: 'missing'
+        };
+    }
+
+    let firstError: FuncMatchError | null = null;
+    let bestFunc: {
+        func: Func;
+        conversions: number;
+    } | null = null;
+    for (let i = 0; i < list.length; ++i) {
+        const match = matchFuncArgs(list[i], args, list.length > 1);
+        if (match.type === 'match') {
+            if (!bestFunc || bestFunc.conversions > match.conversions) {
+                bestFunc = {
+                    func: list[i],
+                    conversions: match.conversions
+                };
+            }
+            continue;
+        }
+        if (!firstError) {
+            firstError = match;
+        }
+    }
+
+    if (!bestFunc) {
+        if (firstError) {
+            return firstError;
+        }
+        throw new Error('Missing function');
+    }
+
+    return bestFunc;
+}
+
+export function findBestMatchedFunc(map: Map<string, Func[]>, funcName: string, args: EvalValue[]): FuncMatch {
+    return findBestMatchedFuncList(map.get(funcName), args);
+}
+
+export function convertArgs(func: Func, args: EvalValue[]): EvalValue[] {
+    return args.map((arg, i) => {
+        let funcArg = i >= func.args.length ? func.args[func.args.length - 1] : func.args[i];
+        if (typeof funcArg !== 'object') {
+            funcArg = {
+                type: funcArg
+            };
+        }
+
+        if (funcArg.type === NUMBER && arg.type === INTEGER) {
+            return integerToNumber(arg);
+        }
+
+        return arg;
+    });
+}
+
+export function funcToKey(funcName: string, func: Func): string {
+    return funcName + ':' + func.args.map(arg => typeof arg === 'string' ? arg : arg.type).join('#');
+}

package/src/expressions/funcs/index.ts

@@ -0,0 +1,23 @@
+import { registerStd } from './std';
+import { registerDatetime } from './datetime';
+import { registerStrings } from './strings';
+import { registerMath } from './math';
+import { registerColors } from './colors';
+import { registerInterval } from './interval';
+import { registerDict } from './dict';
+import { registerArray } from './array';
+import { registerStored } from './stored';
+import { registerTrigonometry } from './trigonometry';
+
+export function register(): void {
+    registerStd();
+    registerDatetime();
+    registerInterval();
+    registerStrings();
+    registerMath();
+    registerColors();
+    registerDict();
+    registerArray();
+    registerStored();
+    registerTrigonometry();
+}

package/src/expressions/funcs/interval.ts

@@ -0,0 +1,76 @@
+import type { EvalContext, EvalValue, IntegerValue } from '../eval';
+import { registerFunc } from './funcs';
+import { INTEGER } from '../const';
+import { toBigInt } from '../bigint';
+import { checkIntegerOverflow } from '../utils';
+
+function getDuration(ctx: EvalContext, milliseconds: IntegerValue, delimiter: number, whole?: number): EvalValue {
+    if (milliseconds.value < 0) {
+        throw new Error('Expecting non-negative number of milliseconds.');
+    }
+
+    let val = toBigInt(milliseconds.value) / toBigInt(delimiter);
+
+    checkIntegerOverflow(ctx, val);
+
+    if (whole) {
+        val = toBigInt(val) % toBigInt(whole);
+    }
+
+    return {
+        type: INTEGER,
+        value: val
+    };
+}
+
+const MS_IN_SECOND = 1000;
+const SECONDS_IN_MINUTE = 60;
+const MS_IN_MINUTE = 1000 * 60;
+const MINUTES_IN_HOUR = 60;
+const MS_IN_HOUR = 1000 * 60 * 60;
+const HOURS_IN_DAY = 24;
+const MS_IN_DAY = 1000 * 60 * 60 * 24;
+const MS_IN_WEEK = 1000 * 60 * 60 * 24 * 7;
+
+function getIntervalSeconds(ctx: EvalContext, milliseconds: IntegerValue): EvalValue {
+    return getDuration(ctx, milliseconds, MS_IN_SECOND, SECONDS_IN_MINUTE);
+}
+
+function getIntervalTotalSeconds(ctx: EvalContext, milliseconds: IntegerValue): EvalValue {
+    return getDuration(ctx, milliseconds, MS_IN_SECOND);
+}
+
+function getIntervalMinutes(ctx: EvalContext, milliseconds: IntegerValue): EvalValue {
+    return getDuration(ctx, milliseconds, MS_IN_MINUTE, MINUTES_IN_HOUR);
+}
+
+function getIntervalTotalMinutes(ctx: EvalContext, milliseconds: IntegerValue): EvalValue {
+    return getDuration(ctx, milliseconds, MS_IN_MINUTE);
+}
+
+function getIntervalHours(ctx: EvalContext, milliseconds: IntegerValue): EvalValue {
+    return getDuration(ctx, milliseconds, MS_IN_HOUR, HOURS_IN_DAY);
+}
+
+function getIntervalTotalHours(ctx: EvalContext, milliseconds: IntegerValue): EvalValue {
+    return getDuration(ctx, milliseconds, MS_IN_HOUR);
+}
+
+function getIntervalTotalDays(ctx: EvalContext, milliseconds: IntegerValue): EvalValue {
+    return getDuration(ctx, milliseconds, MS_IN_DAY);
+}
+
+function getIntervalTotalWeeks(ctx: EvalContext, milliseconds: IntegerValue): EvalValue {
+    return getDuration(ctx, milliseconds, MS_IN_WEEK);
+}
+
+export function registerInterval(): void {
+    registerFunc('getIntervalSeconds', [INTEGER], getIntervalSeconds);
+    registerFunc('getIntervalTotalSeconds', [INTEGER], getIntervalTotalSeconds);
+    registerFunc('getIntervalMinutes', [INTEGER], getIntervalMinutes);
+    registerFunc('getIntervalTotalMinutes', [INTEGER], getIntervalTotalMinutes);
+    registerFunc('getIntervalHours', [INTEGER], getIntervalHours);
+    registerFunc('getIntervalTotalHours', [INTEGER], getIntervalTotalHours);
+    registerFunc('getIntervalTotalDays', [INTEGER], getIntervalTotalDays);
+    registerFunc('getIntervalTotalWeeks', [INTEGER], getIntervalTotalWeeks);
+}