react-native-divkit 0.1.0-alpha.1

package/src/expressions/funcs/datetime.ts

@@ -0,0 +1,232 @@
+/* eslint-disable no-nested-ternary */
+import type { DatetimeValue, EvalContext, EvalValue, IntegerValue, StringValue } from '../eval';
+import { registerFunc } from './funcs';
+import { DATETIME, INTEGER, STRING } from '../const';
+import { valToString } from '../utils';
+import { toBigInt } from '../bigint';
+import { formatDate } from '../../utils/formatDate';
+
+function getMaxDate(date: Date): number {
+    const copy = new Date(date);
+
+    copy.setUTCMonth(copy.getUTCMonth() + 1);
+    copy.setUTCDate(0);
+
+    return copy.getUTCDate();
+}
+
+function parseUnixTime(_ctx: EvalContext, arg: IntegerValue): EvalValue {
+    return {
+        type: DATETIME,
+        value: new Date(Number(arg.value) * 1000)
+    };
+}
+
+function parseUnixTimeAsLocal(_ctx: EvalContext, arg: IntegerValue): EvalValue {
+    const date = new Date(Number(arg.value) * 1000);
+    const offset = date.getTimezoneOffset();
+    date.setMinutes(date.getMinutes() - offset);
+
+    return {
+        type: DATETIME,
+        value: date
+    };
+}
+
+function nowLocal(): EvalValue {
+    return {
+        type: DATETIME,
+        value: new Date()
+    };
+}
+
+function addMillis(_ctx: EvalContext, datetime: DatetimeValue, milliseconds: IntegerValue): EvalValue {
+    return {
+        type: DATETIME,
+        value: new Date(datetime.value.getTime() + Number(milliseconds.value))
+    };
+}
+
+function setYear(_ctx: EvalContext, datetime: DatetimeValue, year: IntegerValue): EvalValue {
+    const copy = new Date(datetime.value);
+
+    copy.setUTCFullYear(Number(year.value));
+
+    return {
+        type: DATETIME,
+        value: copy
+    };
+}
+
+function setMonth(_ctx: EvalContext, datetime: DatetimeValue, month: IntegerValue): EvalValue {
+    const intVal = Number(month.value);
+
+    if (intVal < 1 || intVal > 12) {
+        throw new Error(`Expecting month in [1..12], instead got ${intVal}.`);
+    }
+
+    const copy = new Date(datetime.value);
+    copy.setUTCMonth(intVal - 1);
+
+    return {
+        type: DATETIME,
+        value: copy
+    };
+}
+
+function setDay(_ctx: EvalContext, datetime: DatetimeValue, day: IntegerValue): EvalValue {
+    const copy = new Date(datetime.value);
+    const intVal = Number(day.value);
+
+    if (intVal <= 0 && intVal !== -1 || intVal > getMaxDate(copy)) {
+        throw new Error(`Unable to set day ${intVal} for date ${valToString(datetime, false)}.`);
+    }
+
+    copy.setUTCDate(intVal === -1 ? 0 : intVal);
+
+    return {
+        type: DATETIME,
+        value: copy
+    };
+}
+
+function setHours(_ctx: EvalContext, datetime: DatetimeValue, hours: IntegerValue): EvalValue {
+    const intVal = Number(hours.value);
+
+    if (intVal < 0 || intVal > 23) {
+        throw new Error(`Expecting hours in [0..23], instead got ${intVal}.`);
+    }
+
+    const copy = new Date(datetime.value);
+    copy.setUTCHours(intVal);
+
+    return {
+        type: DATETIME,
+        value: copy
+    };
+}
+
+function setMinutes(_ctx: EvalContext, datetime: DatetimeValue, minutes: IntegerValue): EvalValue {
+    const intVal = Number(minutes.value);
+
+    if (intVal < 0 || intVal > 59) {
+        throw new Error(`Expecting minutes in [0..59], instead got ${intVal}.`);
+    }
+
+    const copy = new Date(datetime.value);
+
+    copy.setUTCMinutes(intVal);
+
+    return {
+        type: DATETIME,
+        value: copy
+    };
+}
+
+function setSeconds(_ctx: EvalContext, datetime: DatetimeValue, seconds: IntegerValue): EvalValue {
+    const intVal = Number(seconds.value);
+
+    if (intVal < 0 || intVal > 59) {
+        throw new Error(`Expecting seconds in [0..59], instead got ${intVal}.`);
+    }
+
+    const copy = new Date(datetime.value);
+    copy.setUTCSeconds(intVal);
+
+    return {
+        type: DATETIME,
+        value: copy
+    };
+}
+
+function setMillis(_ctx: EvalContext, datetime: DatetimeValue, millis: IntegerValue): EvalValue {
+    const intVal = Number(millis.value);
+
+    if (intVal < 0 || intVal > 999) {
+        throw new Error(`Expecting millis in [0..999], instead got ${intVal}.`);
+    }
+
+    const copy = new Date(datetime.value);
+    copy.setUTCMilliseconds(intVal);
+
+    return {
+        type: DATETIME,
+        value: copy
+    };
+}
+
+const getter = (
+    method: 'getUTCFullYear' | 'getUTCMonth' | 'getUTCDate' | 'getUTCDay' | 'getUTCHours' | 'getUTCMinutes' |
+        'getUTCSeconds' | 'getUTCMilliseconds'
+) => {
+    return (_ctx: EvalContext, datetime: DatetimeValue): EvalValue => {
+        const copy = new Date(datetime.value.getTime());
+
+        let value: number = copy[method]();
+
+        if (method === 'getUTCMonth') {
+            ++value;
+        } else if (method === 'getUTCDay' && value === 0) {
+            value = 7;
+        }
+
+        return {
+            type: INTEGER,
+            value: toBigInt(value)
+        };
+    };
+};
+
+function makeFormat(isUTC: boolean) {
+    return (ctx: EvalContext, datetime: DatetimeValue, format: StringValue, locale?: StringValue): EvalValue => {
+        return {
+            type: STRING,
+            value: formatDate(datetime.value, format.value, {
+                locale: locale?.value,
+                isUTC,
+                weekStartDay: ctx.weekStartDay
+            })
+        };
+    };
+}
+
+const getYear = getter('getUTCFullYear');
+const getMonth = getter('getUTCMonth');
+const getDay = getter('getUTCDate');
+const getDayOfWeek = getter('getUTCDay');
+const getHours = getter('getUTCHours');
+const getMinutes = getter('getUTCMinutes');
+const getSeconds = getter('getUTCSeconds');
+const getMillis = getter('getUTCMilliseconds');
+
+const formatAsLocal = makeFormat(false);
+const formatAsUTC = makeFormat(true);
+
+export function registerDatetime(): void {
+    registerFunc('parseUnixTime', [INTEGER], parseUnixTime);
+    registerFunc('parseUnixTimeAsLocal', [INTEGER], parseUnixTimeAsLocal);
+    registerFunc('nowLocal', [], nowLocal);
+    registerFunc('addMillis', [DATETIME, INTEGER], addMillis);
+
+    registerFunc('setYear', [DATETIME, INTEGER], setYear);
+    registerFunc('setMonth', [DATETIME, INTEGER], setMonth);
+    registerFunc('setDay', [DATETIME, INTEGER], setDay);
+    registerFunc('setHours', [DATETIME, INTEGER], setHours);
+    registerFunc('setMinutes', [DATETIME, INTEGER], setMinutes);
+    registerFunc('setSeconds', [DATETIME, INTEGER], setSeconds);
+    registerFunc('setMillis', [DATETIME, INTEGER], setMillis);
+
+    registerFunc('getYear', [DATETIME], getYear);
+    registerFunc('getMonth', [DATETIME], getMonth);
+    registerFunc('getDay', [DATETIME], getDay);
+    registerFunc('getDayOfWeek', [DATETIME], getDayOfWeek);
+    registerFunc('getHours', [DATETIME], getHours);
+    registerFunc('getMinutes', [DATETIME], getMinutes);
+    registerFunc('getSeconds', [DATETIME], getSeconds);
+    registerFunc('getMillis', [DATETIME], getMillis);
+
+    registerFunc('formatDateAsLocal', [DATETIME, STRING], formatAsLocal);
+    registerFunc('formatDateAsUTC', [DATETIME, STRING], formatAsUTC);
+    registerFunc('formatDateAsLocalWithLocale', [DATETIME, STRING, STRING], formatAsLocal);
+    registerFunc('formatDateAsUTCWithLocale', [DATETIME, STRING, STRING], formatAsUTC);
+}

package/src/expressions/funcs/dict.ts

@@ -0,0 +1,207 @@
+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 { checkUrl, convertJsValueToDivKit, transformColorValue } from '../utils';
+import { registerFunc, registerMethod } from './funcs';
+
+function getProp(obj: object, path: string[]): unknown {
+    let current: object = obj;
+
+    for (let i = 0; i < path.length; ++i) {
+        if (!current) {
+            throw new Error(`Missing property "${path[i]}" in the dict.`);
+        }
+        const val = current[path[i] as keyof typeof current];
+        if (val === undefined) {
+            throw new Error(`Missing property "${path[i]}" in the dict.`);
+        }
+        current = val;
+    }
+
+    return current;
+}
+
+function dictGetter(evalType: EvalTypesWithoutDatetime) {
+    return (ctx: EvalContext, dict: DictValue, ...path: StringValue[]): EvalValue => {
+        if (path.length === 0) {
+            throw new Error('Non empty argument list is required.');
+        }
+
+        const val = getProp(dict.value, path.map(it => it.value));
+
+        return convertJsValueToDivKit(ctx, val, evalType);
+    };
+}
+
+function optWrapper<ValueType extends EvalValue>(
+    func: (ctx: EvalContext, dict: DictValue, ...path: StringValue[]) => EvalValue,
+    fallbackType: EvalTypes
+) {
+    return (ctx: EvalContext, fallback: ValueType, dict: DictValue, ...path: StringValue[]) => {
+        try {
+            return func(ctx, dict, ...path);
+        } catch (_err) {
+            // ignore error
+
+            let value = fallback.value;
+            if (fallbackType === 'color') {
+                value = transformColorValue(value as string);
+            } else if (fallbackType === 'url') {
+                checkUrl(value);
+            }
+            return {
+                type: fallbackType,
+                value
+            } as unknown as EvalValue;
+        }
+    };
+}
+
+const getDictString = dictGetter(STRING);
+const getDictNumber = dictGetter(NUMBER);
+const getDictInteger = dictGetter(INTEGER);
+const getDictBoolean = dictGetter(BOOLEAN);
+const getDictColor = dictGetter(COLOR);
+const getDictUrl = dictGetter(URL);
+const getDictArray = dictGetter(ARRAY);
+const getDictDict = dictGetter(DICT);
+
+const getDictOptString = optWrapper<StringValue>(getDictString, STRING);
+const getDictOptNumber = optWrapper<NumberValue>(getDictNumber, NUMBER);
+const getDictOptInteger = optWrapper<IntegerValue>(getDictInteger, INTEGER);
+const getDictOptBoolean = optWrapper<BooleanValue>(getDictBoolean, BOOLEAN);
+const getDictOptColor = optWrapper<BooleanValue>(getDictColor, COLOR);
+const getDictOptUrl = optWrapper<BooleanValue>(getDictUrl, URL);
+
+function getDictOptArray(ctx: EvalContext, dict: DictValue, ...path: StringValue[]): EvalValue {
+    try {
+        return getDictArray(ctx, dict, ...path);
+    } catch (_err) {
+        // ignore error
+        return {
+            type: ARRAY,
+            value: []
+        } as unknown as EvalValue;
+    }
+}
+
+function getDictOptDict(ctx: EvalContext, dict: DictValue, ...path: StringValue[]): EvalValue {
+    try {
+        return getDictDict(ctx, dict, ...path);
+    } catch (_err) {
+        // ignore error
+        return {
+            type: DICT,
+            value: {}
+        } as unknown as EvalValue;
+    }
+}
+
+function containsKey(_ext: EvalContext, dict: DictValue, key: StringValue): BooleanValue {
+    return {
+        type: BOOLEAN,
+        value: key.value in dict.value ? 1 : 0
+    };
+}
+
+function isEmpty(_ext: EvalContext, dict: DictValue): BooleanValue {
+    return {
+        type: BOOLEAN,
+        value: Object.keys(dict.value).length ? 0 : 1
+    };
+}
+
+function len(_ext: EvalContext, dict: DictValue): IntegerValue {
+    return {
+        type: INTEGER,
+        value: toBigInt(Object.keys(dict.value).length)
+    };
+}
+
+function getDictKeys(_ext: EvalContext, dict: DictValue): ArrayValue {
+    return {
+        type: ARRAY,
+        value: Object.keys(dict.value)
+    };
+}
+
+function getDictValues(_ext: EvalContext, dict: DictValue): ArrayValue {
+    return {
+        type: ARRAY,
+        value: Object.values(dict.value)
+    };
+}
+
+export function registerDict(): void {
+    const STRING_VARARG = {
+        type: STRING,
+        isVararg: true
+    } as const;
+
+    registerFunc('getDictString', [DICT, STRING_VARARG], getDictString);
+    registerFunc('getStringFromDict', [DICT, STRING_VARARG], getDictString);
+
+    registerFunc('getDictNumber', [DICT, STRING_VARARG], getDictNumber);
+    registerFunc('getNumberFromDict', [DICT, STRING_VARARG], getDictNumber);
+
+    registerFunc('getDictInteger', [DICT, STRING_VARARG], getDictInteger);
+    registerFunc('getIntegerFromDict', [DICT, STRING_VARARG], getDictInteger);
+
+    registerFunc('getDictBoolean', [DICT, STRING_VARARG], getDictBoolean);
+    registerFunc('getBooleanFromDict', [DICT, STRING_VARARG], getDictBoolean);
+
+    registerFunc('getDictColor', [DICT, STRING_VARARG], getDictColor);
+    registerFunc('getColorFromDict', [DICT, STRING_VARARG], getDictColor);
+
+    registerFunc('getDictUrl', [DICT, STRING_VARARG], getDictUrl);
+    registerFunc('getUrlFromDict', [DICT, STRING_VARARG], getDictUrl);
+
+    registerFunc('getDictOptString', [STRING, DICT, STRING_VARARG], getDictOptString);
+    registerFunc('getOptStringFromDict', [STRING, DICT, STRING_VARARG], getDictOptString);
+
+    registerFunc('getDictOptNumber', [NUMBER, DICT, STRING_VARARG], getDictOptNumber);
+    registerFunc('getOptNumberFromDict', [NUMBER, DICT, STRING_VARARG], getDictOptNumber);
+
+    registerFunc('getDictOptInteger', [INTEGER, DICT, STRING_VARARG], getDictOptInteger);
+    registerFunc('getOptIntegerFromDict', [INTEGER, DICT, STRING_VARARG], getDictOptInteger);
+
+    registerFunc('getDictOptBoolean', [BOOLEAN, DICT, STRING_VARARG], getDictOptBoolean);
+    registerFunc('getOptBooleanFromDict', [BOOLEAN, DICT, STRING_VARARG], getDictOptBoolean);
+
+    registerFunc('getDictOptColor', [COLOR, DICT, STRING_VARARG], getDictOptColor);
+    registerFunc('getOptColorFromDict', [COLOR, DICT, STRING_VARARG], getDictOptColor);
+
+    registerFunc('getDictOptColor', [STRING, DICT, STRING_VARARG], getDictOptColor);
+    registerFunc('getOptColorFromDict', [STRING, DICT, STRING_VARARG], getDictOptColor);
+
+    registerFunc('getDictOptUrl', [STRING, DICT, STRING_VARARG], getDictOptUrl);
+    registerFunc('getOptUrlFromDict', [STRING, DICT, STRING_VARARG], getDictOptUrl);
+
+    registerFunc('getDictOptUrl', [URL, DICT, STRING_VARARG], getDictOptUrl);
+    registerFunc('getOptUrlFromDict', [URL, DICT, STRING_VARARG], getDictOptUrl);
+
+    registerFunc('getDictFromDict', [DICT, STRING_VARARG], getDictDict);
+
+    registerFunc('getArrayFromDict', [DICT, STRING_VARARG], getDictArray);
+
+    registerFunc('getOptArrayFromDict', [DICT, STRING_VARARG], getDictOptArray);
+
+    registerFunc('getOptDictFromDict', [DICT, STRING_VARARG], getDictOptDict);
+
+    registerFunc('len', [DICT], len);
+    registerFunc('getDictKeys', [DICT], getDictKeys);
+    registerFunc('getDictValues', [DICT], getDictValues);
+
+    registerMethod('getString', [DICT, STRING_VARARG], getDictString);
+    registerMethod('getBoolean', [DICT, STRING_VARARG], getDictBoolean);
+    registerMethod('getInteger', [DICT, STRING_VARARG], getDictInteger);
+    registerMethod('getNumber', [DICT, STRING_VARARG], getDictNumber);
+    registerMethod('getUrl', [DICT, STRING_VARARG], getDictUrl);
+    registerMethod('getColor', [DICT, STRING_VARARG], getDictColor);
+    registerMethod('getArray', [DICT, STRING_VARARG], getDictArray);
+    registerMethod('getDict', [DICT, STRING_VARARG], getDictDict);
+    registerMethod('containsKey', [DICT, STRING], containsKey);
+    registerMethod('isEmpty', [DICT], isEmpty);
+    registerMethod('getKeys', [DICT], getDictKeys);
+    registerMethod('getValues', [DICT], getDictValues);
+}