react-native-divkit 0.1.0-alpha.1

package/src/expressions/funcs/std.ts

@@ -0,0 +1,392 @@
+import type {
+    ArrayValue,
+    BooleanValue,
+    ColorValue,
+    DictValue,
+    EvalContext,
+    EvalValue,
+    IntegerValue,
+    NumberValue,
+    StringValue,
+    UrlValue
+} from '../eval';
+import type { VariableType, VariableValue } from '../variable';
+import { registerFunc, registerMethod } from './funcs';
+import { ARRAY, BOOLEAN, COLOR, DICT, INTEGER, NUMBER, STRING, URL } from '../const';
+import { checkUrl, transformColorValue, valToString } from '../utils';
+import { MAX_INT, MIN_INT, toBigInt } from '../bigint';
+
+function toString(
+    _ctx: EvalContext,
+    arg: IntegerValue | NumberValue | BooleanValue | ColorValue | UrlValue | StringValue | ArrayValue | DictValue
+): EvalValue {
+    return {
+        type: STRING,
+        value: valToString(arg, true)
+    };
+}
+
+
+function toNumber(_ctx: EvalContext, arg: IntegerValue | StringValue): EvalValue {
+    const num = Number(arg.value);
+
+    if (Number.isNaN(num) || !Number.isFinite(num)) {
+        throw new Error('Unable to convert value to Number.');
+    }
+    if (arg.value === '') {
+        throw new Error('Unable to convert value to Number.');
+    }
+
+    return {
+        type: NUMBER,
+        value: num
+    };
+}
+
+
+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.');
+    }
+
+    const num = arg.value - (arg.value % 1);
+
+    return {
+        type: INTEGER,
+        value: toBigInt(num)
+    };
+}
+
+function toIntegerString(_ctx: EvalContext, arg: StringValue): EvalValue {
+    let num: bigint;
+
+    try {
+        num = toBigInt(arg.value);
+    } catch (err) {
+        throw new Error('Unable to convert value to Integer.');
+    }
+
+    return {
+        type: INTEGER,
+        value: num
+    };
+}
+
+function toIntegerBoolean(_ctx: EvalContext, arg: BooleanValue): EvalValue {
+    return {
+        type: INTEGER,
+        value: toBigInt(arg.value ? 1 : 0)
+    };
+}
+
+
+function toBooleanInteger(_ctx: EvalContext, arg: IntegerValue): EvalValue {
+    const intVal = Number(arg.value);
+    if (intVal !== 1 && intVal !== 0) {
+        throw new Error('Unable to convert value to Boolean.');
+    }
+
+    return {
+        type: BOOLEAN,
+        value: intVal
+    };
+}
+
+function toBooleanString(_ctx: EvalContext, arg: StringValue): EvalValue {
+    if (arg.value !== 'true' && arg.value !== 'false') {
+        throw new Error('Unable to convert value to Boolean.');
+    }
+
+    return {
+        type: BOOLEAN,
+        value: arg.value === 'true' ? 1 : 0
+    };
+}
+
+function toColor(_ctx: EvalContext, arg: StringValue): EvalValue {
+    return {
+        type: COLOR,
+        value: transformColorValue(arg.value)
+    };
+}
+
+function toUrl(_ctx: EvalContext, arg: StringValue): EvalValue {
+    checkUrl(arg.value);
+
+    return {
+        type: URL,
+        value: arg.value
+    };
+}
+
+function encodeUri(_ctx: EvalContext, str: StringValue): EvalValue {
+    try {
+        return {
+            type: STRING,
+            value: encodeURIComponent(str.value)
+        };
+    } catch (_err) {
+        throw new Error('Unable to encodeUri string.');
+    }
+}
+
+function decodeUri(_ctx: EvalContext, str: StringValue): EvalValue {
+    try {
+        return {
+            type: STRING,
+            value: decodeURIComponent(str.value)
+        };
+    } catch (_err) {
+        throw new Error('Unable to decodeUri string.');
+    }
+}
+
+function getValueForced(
+    ctx: EvalContext,
+    varName: StringValue,
+    fallback: IntegerValue | NumberValue | StringValue | BooleanValue | UrlValue | ColorValue,
+    type: VariableType
+): EvalValue {
+    const variable = ctx.variables.get(varName.value);
+    let value: VariableValue;
+
+    if (variable && variable.getType() === type) {
+        value = variable.getValue();
+
+        if (!ctx.storeUsedVars) {
+            ctx.storeUsedVars = new Set();
+        }
+        ctx.storeUsedVars.add(variable);
+    } else {
+        value = fallback.value;
+    }
+
+    if (type === 'color') {
+        value = transformColorValue(value as string);
+    } else if (type === 'url') {
+        checkUrl(value);
+    }
+
+    return {
+        type,
+        // value is synced with type by params
+        value: value as any
+    };
+}
+
+function getValue(
+    ctx: EvalContext,
+    varName: StringValue,
+    fallback: IntegerValue | NumberValue | StringValue | BooleanValue | UrlValue | ColorValue
+): EvalValue {
+    return getValueForced(ctx, varName, fallback, fallback.type);
+}
+
+function getColorValue(
+    ctx: EvalContext,
+    varName: StringValue,
+    fallback: IntegerValue | NumberValue | StringValue | BooleanValue | UrlValue | ColorValue
+) {
+    return getValueForced(ctx, varName, fallback, 'color');
+}
+
+function getUrlValue(
+    ctx: EvalContext,
+    varName: StringValue,
+    fallback: IntegerValue | NumberValue | StringValue | BooleanValue | UrlValue | ColorValue
+) {
+    return getValueForced(ctx, varName, fallback, 'url');
+}
+
+function firstDiffChar(str0: string, str1: string): string {
+    for (let i = 0; i < str1.length; ++i) {
+        const char0 = str0.charAt(i);
+        const char1 = str1.charAt(i);
+
+        if (char0 !== char1 && char1) {
+            return char1;
+        }
+    }
+
+    return '';
+}
+
+const TEST_NUMBER = 1234567890;
+
+function numberFractionDivider(locale?: string): string {
+    const formatter0 = new Intl.NumberFormat(locale, {
+        maximumFractionDigits: 0
+    });
+    const formatter1 = new Intl.NumberFormat(locale, {
+        minimumFractionDigits: 1
+    });
+
+    const str0 = formatter0.format(TEST_NUMBER);
+    const str1 = formatter1.format(TEST_NUMBER);
+
+    return firstDiffChar(str0, str1);
+}
+
+function numberGroupingDivider(locale?: string): string {
+    const formatter0 = new Intl.NumberFormat(locale, {
+        useGrouping: false
+    });
+    const formatter1 = new Intl.NumberFormat(locale, {
+        useGrouping: true
+    });
+
+    const str0 = formatter0.format(TEST_NUMBER);
+    const str1 = formatter1.format(TEST_NUMBER);
+
+    return firstDiffChar(str0, str1);
+}
+
+function decimalFormat(
+    _ctx: EvalContext,
+    arg: IntegerValue | NumberValue,
+    format: StringValue,
+    locale?: StringValue
+): EvalValue {
+    const pattern = format.value;
+    const patternWithoutGroupping = pattern.replace(/,/g, '');
+    if (
+        !/^((#+)|(#*0+))(\.0*#*)?$/.test(patternWithoutGroupping) &&
+        !/^#*0*\.((0*#*)|(#+))$/.test(patternWithoutGroupping) ||
+        /,.*,/.test(pattern) ||
+        pattern.indexOf(',') > pattern.indexOf('.') && pattern.indexOf('.') > -1
+    ) {
+        throw new Error('Incorrect format pattern.');
+    }
+
+    const rawParts = pattern.split('.');
+    const rawInteger = rawParts[0];
+    const rawFraction = rawParts[1] || '';
+
+    const parts = pattern.replace(/[^#0.]/g, '').split('.');
+    const integer = parts[0];
+    const fraction = parts[1] || '';
+
+    const groupIndex = rawInteger.indexOf(',');
+    const digitsInGroup = groupIndex > -1 ? rawInteger.length - groupIndex - 1 : -1;
+
+    if (groupIndex > -1 && digitsInGroup < 1 || rawFraction.indexOf(',') > -1) {
+        throw new Error('Incorrect format pattern.');
+    }
+
+    try {
+        let minimumIntegerDigits = 0;
+        while (integer[integer.length - 1 - minimumIntegerDigits] === '0') {
+            ++minimumIntegerDigits;
+        }
+        let minimumFractionDigits = 0;
+        while (fraction[minimumFractionDigits] === '0') {
+            ++minimumFractionDigits;
+        }
+        let maximumFractionDigits = minimumFractionDigits;
+        while (fraction[maximumFractionDigits] === '#') {
+            ++maximumFractionDigits;
+        }
+
+        const formatter = new Intl.NumberFormat(locale?.value || undefined, {
+            useGrouping: false,
+            minimumIntegerDigits: Math.min(Math.max(minimumIntegerDigits, 1), 21),
+            minimumFractionDigits: Math.min(Math.max(minimumFractionDigits, 0), 100),
+            maximumFractionDigits: Math.min(Math.max(maximumFractionDigits, minimumFractionDigits, 0), 100),
+            roundingMode: 'halfEven' as any
+        } as any);
+
+        let result = formatter.format(arg.value);
+
+        if (groupIndex > -1 && digitsInGroup > 0) {
+            const groupChar = numberGroupingDivider(locale?.value);
+            const fractionChar = numberFractionDivider(locale?.value);
+
+            if (groupChar && fractionChar) {
+                const resultParts = result.split(fractionChar);
+                const resultInteger = resultParts[0];
+                let res = '';
+                for (let i = resultInteger.length - 1; i >= 0; --i) {
+                    res = resultInteger[i] + res;
+
+                    // eslint-disable-next-line max-depth
+                    if (i > 0 && (resultInteger.length - i) % digitsInGroup === 0) {
+                        res = groupChar + res;
+                    }
+                }
+
+                result = res + (resultParts.length > 1 ? fractionChar + resultParts[1] : '');
+            }
+        }
+
+        if (minimumFractionDigits === 0 && maximumFractionDigits === 0 && pattern.endsWith('.')) {
+            // force fraction delimeter on end
+            const divider = numberFractionDivider(locale?.value);
+            if (divider) {
+                result += divider;
+            }
+        }
+
+        return {
+            type: STRING,
+            value: result
+        };
+    } catch (_err) {
+        throw new Error('Incorrect or unsupported number format.' + _err + ' ' + locale?.value || undefined);
+    }
+}
+
+export function registerStd(): void {
+    registerFunc('toString', [INTEGER], toString);
+    registerFunc('toString', [NUMBER], toString);
+    registerFunc('toString', [BOOLEAN], toString);
+    registerFunc('toString', [COLOR], toString);
+    registerFunc('toString', [URL], toString);
+    registerFunc('toString', [STRING], toString);
+    registerFunc('toString', [ARRAY], toString);
+    registerFunc('toString', [DICT], toString);
+
+    registerFunc('toNumber', [INTEGER], toNumber);
+    registerFunc('toNumber', [STRING], toNumber);
+
+    registerFunc('toInteger', [NUMBER], toIntegerNumber);
+    registerFunc('toInteger', [STRING], toIntegerString);
+    registerFunc('toInteger', [BOOLEAN], toIntegerBoolean);
+
+    registerFunc('toBoolean', [INTEGER], toBooleanInteger);
+    registerFunc('toBoolean', [STRING], toBooleanString);
+
+    registerFunc('toColor', [STRING], toColor);
+
+    registerFunc('toUrl', [STRING], toUrl);
+
+    registerFunc('encodeUri', [STRING], encodeUri);
+    registerFunc('decodeUri', [STRING], decodeUri);
+
+    registerFunc('getIntegerValue', [STRING, INTEGER], getValue);
+    registerFunc('getNumberValue', [STRING, NUMBER], getValue);
+    registerFunc('getBooleanValue', [STRING, BOOLEAN], getValue);
+    registerFunc('getStringValue', [STRING, STRING], getValue);
+    registerFunc('getColorValue', [STRING, COLOR], getColorValue);
+    registerFunc('getColorValue', [STRING, STRING], getColorValue);
+    registerFunc('getUrlValue', [STRING, URL], getUrlValue);
+    registerFunc('getUrlValue', [STRING, STRING], getUrlValue);
+
+    registerMethod('toString', [INTEGER], toString);
+    registerMethod('toString', [NUMBER], toString);
+    registerMethod('toString', [BOOLEAN], toString);
+    registerMethod('toString', [COLOR], toString);
+    registerMethod('toString', [URL], toString);
+    registerMethod('toString', [STRING], toString);
+    registerMethod('toString', [ARRAY], toString);
+    registerMethod('toString', [DICT], toString);
+
+    registerFunc('decimalFormat', [INTEGER, STRING], decimalFormat);
+    registerFunc('decimalFormat', [NUMBER, STRING], decimalFormat);
+    registerFunc('decimalFormat', [INTEGER, STRING, STRING], decimalFormat);
+    registerFunc('decimalFormat', [NUMBER, STRING, STRING], decimalFormat);
+
+    registerMethod('decimalFormat', [INTEGER, STRING], decimalFormat);
+    registerMethod('decimalFormat', [NUMBER, STRING], decimalFormat);
+    registerMethod('decimalFormat', [INTEGER, STRING, STRING], decimalFormat);
+    registerMethod('decimalFormat', [NUMBER, STRING, STRING], decimalFormat);
+}

package/src/expressions/funcs/stored.ts

@@ -0,0 +1,62 @@
+import type { EvalContext, EvalValue, StringValue } from '../eval';
+import { registerFunc } from './funcs';
+import { ARRAY, BOOLEAN, COLOR, DICT, INTEGER, NUMBER, STRING, URL } from '../const';
+import { checkUrl, convertJsValueToDivKit } from '../utils';
+
+export function getStored(evalType: 'string' | 'number' | 'integer' | 'boolean' | 'color' | 'url' | 'array' | 'dict') {
+    return (ctx: EvalContext, name: StringValue, fallback?: EvalValue): EvalValue => {
+        if (!ctx.store) {
+            if (!fallback) {
+                throw new Error('Missing value.');
+            }
+            return {
+                type: evalType,
+                value: fallback.value
+            } as EvalValue;
+        }
+        let expectedType: 'boolean' | 'number' | 'string';
+        if (evalType === 'boolean') {
+            expectedType = 'boolean';
+        } else if (evalType === 'number' || evalType === 'integer') {
+            expectedType = 'number';
+        } else {
+            expectedType = 'string';
+        }
+        let val;
+        if (ctx.store.get) {
+            val = ctx.store.get(name.value, evalType);
+        } else if (ctx.store.getValue) {
+            val = ctx.store.getValue(name.value, expectedType);
+        }
+
+        if (val === undefined) {
+            if (!fallback) {
+                throw new Error('Missing value.');
+            }
+            if (evalType === 'url') {
+                checkUrl(fallback.value);
+            }
+            return {
+                type: evalType,
+                value: fallback.value
+            } as EvalValue;
+        } else if (evalType === 'url') {
+            checkUrl(val);
+        }
+
+        return convertJsValueToDivKit(ctx, val, evalType);
+    };
+}
+
+export function registerStored(): void {
+    registerFunc('getStoredIntegerValue', [STRING, INTEGER], getStored(INTEGER));
+    registerFunc('getStoredNumberValue', [STRING, NUMBER], getStored(NUMBER));
+    registerFunc('getStoredStringValue', [STRING, STRING], getStored(STRING));
+    registerFunc('getStoredUrlValue', [STRING, URL], getStored(URL));
+    registerFunc('getStoredUrlValue', [STRING, STRING], getStored(URL));
+    registerFunc('getStoredColorValue', [STRING, COLOR], getStored(COLOR));
+    registerFunc('getStoredColorValue', [STRING, STRING], getStored(COLOR));
+    registerFunc('getStoredBooleanValue', [STRING, BOOLEAN], getStored(BOOLEAN));
+    registerFunc('getStoredArrayValue', [STRING], getStored(ARRAY));
+    registerFunc('getStoredDictValue', [STRING], getStored(DICT));
+}

package/src/expressions/funcs/strings.ts

@@ -0,0 +1,200 @@
+import type { EvalContext, EvalValue, IntegerValue, StringValue } from '../eval';
+import { registerFunc } from './funcs';
+import { BOOLEAN, INTEGER, STRING } from '../const';
+import { escapeRegExp } from '../../utils/escapeRegExp';
+import { valToString } from '../utils';
+import { wrapError } from '../../utils/wrapError';
+import { toBigInt } from '../bigint';
+
+function len(_ctx: EvalContext, arg: StringValue): EvalValue {
+    return {
+        type: INTEGER,
+        value: toBigInt(arg.value.length)
+    };
+}
+
+function contains(_ctx: EvalContext, wholeStr: StringValue, partStr: StringValue): EvalValue {
+    return {
+        type: BOOLEAN,
+        value: wholeStr.value.includes(partStr.value) ? 1 : 0
+    };
+}
+
+function substring(_ctx: EvalContext, str: StringValue, start: IntegerValue, end: IntegerValue): EvalValue {
+    if (end.value < start.value) {
+        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
+    ) {
+        throw new Error('Indexes are out of bounds.');
+    }
+
+    return {
+        type: STRING,
+        value: str.value.substring(Number(start.value), Number(end.value))
+    };
+}
+
+function replaceAll(_ctx: EvalContext, str: StringValue, what: StringValue, replacer: StringValue): EvalValue {
+    let res: string;
+
+    if (what.value) {
+        res = str.value.replace(new RegExp(escapeRegExp(what.value), 'g'), replacer.value);
+    } else {
+        // empty str
+        res = str.value;
+    }
+
+    return {
+        type: STRING,
+        value: res
+    };
+}
+
+function index(_ctx: EvalContext, str: StringValue, what: StringValue): EvalValue {
+    return {
+        type: INTEGER,
+        value: toBigInt(str.value.indexOf(what.value))
+    };
+}
+
+function lastIndex(_ctx: EvalContext, str: StringValue, what: StringValue): EvalValue {
+    return {
+        type: INTEGER,
+        value: toBigInt(str.value.lastIndexOf(what.value))
+    };
+}
+
+function trim(_ctx: EvalContext, str: StringValue): EvalValue {
+    return {
+        type: STRING,
+        value: str.value.trim()
+    };
+}
+
+function trimLeft(_ctx: EvalContext, str: StringValue): EvalValue {
+    return {
+        type: STRING,
+        value: str.value.replace(/^\s+/, '')
+    };
+}
+
+function trimRight(_ctx: EvalContext, str: StringValue): EvalValue {
+    return {
+        type: STRING,
+        value: str.value.replace(/\s+$/, '')
+    };
+}
+
+function toUpperCase(_ctx: EvalContext, str: StringValue): EvalValue {
+    return {
+        type: STRING,
+        value: str.value.toUpperCase()
+    };
+}
+
+function toLowerCase(_ctx: EvalContext, str: StringValue): EvalValue {
+    return {
+        type: STRING,
+        value: str.value.toLowerCase()
+    };
+}
+
+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'
+        }));
+        return '';
+    }
+
+    let part = '';
+    const str = val.type === STRING ? val.value : valToString(val, false);
+
+    while (part.length + str.length < len.value) {
+        part += pad.value;
+    }
+    if (part.length > 0 && part.length + str.length > len.value) {
+        part = part.substring(0, Number(len.value) - Number(str.length));
+    }
+
+    return part;
+}
+
+function padStart(
+    ctx: EvalContext,
+    val: StringValue | IntegerValue,
+    len: IntegerValue,
+    pad: StringValue
+): EvalValue {
+    const prefix = calcPad(ctx, val, len, pad);
+
+    return {
+        type: STRING,
+        value: prefix + valToString(val, false)
+    };
+}
+
+function padEnd(
+    ctx: EvalContext,
+    val: StringValue | IntegerValue,
+    len: IntegerValue,
+    pad: StringValue
+): EvalValue {
+    const suffix = calcPad(ctx, val, len, pad);
+
+    return {
+        type: STRING,
+        value: valToString(val, false) + suffix
+    };
+}
+
+function testRegex(_ctx: EvalContext, str: StringValue, regex: StringValue): EvalValue {
+    let re: RegExp;
+    try {
+        re = new RegExp(regex.value);
+    } catch (err) {
+        throw new Error('Invalid regular expression.');
+    }
+
+    return {
+        type: BOOLEAN,
+        value: re.test(str.value) ? 1 : 0
+    };
+}
+
+function encodeRegex(_ctx: EvalContext, str: StringValue): EvalValue {
+    return {
+        type: STRING,
+        // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_expressions#escaping
+        value: str.value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+    };
+}
+
+export function registerStrings(): void {
+    registerFunc('len', [STRING], len);
+    registerFunc('contains', [STRING, STRING], contains);
+    registerFunc('substring', [STRING, INTEGER, INTEGER], substring);
+    registerFunc('replaceAll', [STRING, STRING, STRING], replaceAll);
+    registerFunc('index', [STRING, STRING], index);
+    registerFunc('lastIndex', [STRING, STRING], lastIndex);
+    registerFunc('trim', [STRING], trim);
+    registerFunc('trimLeft', [STRING], trimLeft);
+    registerFunc('trimRight', [STRING], trimRight);
+    registerFunc('toUpperCase', [STRING], toUpperCase);
+    registerFunc('toLowerCase', [STRING], toLowerCase);
+    registerFunc('padStart', [STRING, INTEGER, STRING], padStart);
+    registerFunc('padStart', [INTEGER, INTEGER, STRING], padStart);
+    registerFunc('padEnd', [STRING, INTEGER, STRING], padEnd);
+    registerFunc('padEnd', [INTEGER, INTEGER, STRING], padEnd);
+    registerFunc('testRegex', [STRING, STRING], testRegex);
+    registerFunc('encodeRegex', [STRING], encodeRegex);
+}