react-native-divkit 0.1.0-alpha.1

package/src/expressions/utils.ts

@@ -0,0 +1,271 @@
+import type { EvalContext, EvalTypes, EvalTypesWithoutDatetime, EvalValue, EvalValueBase, IntegerValue, NumberValue } from './eval';
+import type { Node, Variable } from './ast';
+import type { VariablesMap } from './eval';
+import { walk } from './walk';
+import { parseColor, type ParsedColor } from '../utils/correctColor';
+import { padLeft } from '../utils/padLeft';
+import { MAX_INT, MIN_INT, toBigInt } from './bigint';
+import { BOOLEAN, NUMBER } from './const';
+import type { TypedValue } from '../../typings/common';
+import type { MaybeMissing } from './json';
+
+export class FuncError extends Error {
+}
+
+export function valToInternal(val: EvalValue): EvalValue {
+    if (val.type === 'url' || val.type === 'color') {
+        return {
+            type: 'string',
+            value: val.value
+        };
+    }
+
+    return val;
+}
+
+export function dateToString(date: Date): string {
+    return date
+        .toISOString()
+        .replace('T', ' ')
+        .replace(/\.\d{3}Z$/, '');
+}
+
+export function valToString(val: EvalValue, stringifyComplex: boolean): string {
+    if (val.type === 'string') {
+        return val.value;
+    } else if (val.type === 'integer') {
+        return String(val.value);
+    } else if (val.type === 'number') {
+        let res = String(val.value);
+
+        if (!res.includes('.')) {
+            if (res.includes('e')) {
+                res = res.replace('e', '.0e');
+            } else {
+                res += '.0';
+            }
+        }
+
+        res = res.replace(/e\+?/i, 'E');
+
+        return res;
+    } else if (val.type === 'boolean') {
+        return val.value ? 'true' : 'false';
+    } else if (val.type === 'datetime') {
+        return dateToString(val.value);
+    } else if (val.type === 'color') {
+        return stringifyColor(safeConvertColor(val.value));
+    } else if (val.type === 'url') {
+        return val.value;
+    } else if ((val.type === 'dict' || val.type === 'array') && stringifyComplex) {
+        return JSON.stringify(val.value);
+    } else if (val.type === 'dict') {
+        return '<dict>';
+    } else if (val.type === 'array') {
+        return '<array>';
+    } else if (val.type === 'function') {
+        return val.value[0].name || 'Function';
+    }
+
+    // For purpose when new eval value types will be added
+    throw new Error(`Unexpected type ${(val as EvalValueBase).type}`);
+}
+
+export function valToPreview(val: EvalValue): string {
+    let res = valToString(val, false);
+
+    if (val.type === 'string') {
+        res = "'" +
+            res
+                .replace(/\\/g, '\\\\')
+                .replace(/'/g, '\\\'') +
+            "'";
+    }
+
+    return res;
+}
+
+export function typeToString(type: string): string {
+    if (type === 'datetime') {
+        return 'DateTime';
+    }
+    return type.charAt(0).toUpperCase() + type.substring(1);
+}
+
+export function roundInteger(_ctx: EvalContext, val: bigint): bigint {
+    return toBigInt(val);
+}
+
+export function checkIntegerOverflow(_ctx: EvalContext, val: number | bigint): void {
+    if (val < MIN_INT || val > MAX_INT) {
+        throw new Error('Integer overflow.');
+    }
+}
+
+export function checkUrl(val: unknown): void {
+    if (typeof val !== 'string') {
+        throw new Error('Incorrect url value.');
+    }
+
+    try {
+        // eslint-disable-next-line no-new
+        new URL(val);
+    } catch (_err) {
+        throw new Error('Incorrect url value.');
+    }
+}
+
+export function safeCheckUrl(val: unknown): boolean {
+    try {
+        checkUrl(val);
+        return true;
+    } catch {
+        return false;
+    }
+}
+
+export function gatherVarsFromAst(ast: Node): string[] {
+    const res = new Set<string>();
+
+    walk(ast, {
+        Variable(node: Variable): void {
+            res.add(node.id.name);
+        }
+    });
+
+    return [...res];
+}
+
+export function evalError(msg: string, details: string): never {
+    throw new FuncError(`Failed to evaluate [${msg}]. ${details}`);
+}
+
+export function evalOuterError(_msg: string, details: string): never {
+    throw new Error(details);
+}
+
+export function containsUnsetVariables(ast: Node, variables: VariablesMap): boolean {
+    let result = false;
+
+    walk(ast, {
+        Variable(node: Variable): void {
+            if (!variables.has(node.id.name)) {
+                result = true;
+            }
+        }
+    });
+
+    return result;
+}
+
+export function safeConvertColor(color: string): ParsedColor {
+    const res = parseColor(color);
+
+    if (res) {
+        return res;
+    }
+
+    throw new Error('Unable to convert value to Color, expected format #AARRGGBB.');
+}
+
+export function stringifyColor(color: ParsedColor): string {
+    return `#${[color.a, color.r, color.g, color.b].map(it => {
+        if (it < 0 || it > 255) {
+            throw new Error('Value out of range 0..1.');
+        }
+
+        return padLeft(Math.round(it).toString(16), 2);
+    }).join('').toUpperCase()}`;
+}
+
+export function transformColorValue(color: string): string {
+    return stringifyColor(safeConvertColor(color));
+}
+
+export function integerToNumber(integerValue: IntegerValue): NumberValue {
+    return {
+        type: NUMBER,
+        value: Number(integerValue.value)
+    };
+}
+
+const EVAL_TYPE_TO_JS_TYPE = {
+    string: 'string',
+    number: 'number',
+    integer: 'number',
+    boolean: 'boolean',
+    color: 'string',
+    url: 'string',
+    array: 'array',
+    dict: 'object',
+    datetime: 'never'
+};
+export function convertJsValueToDivKit(
+    ctx: EvalContext | undefined,
+    val: unknown,
+    evalType: EvalTypes
+): EvalValue {
+    if (evalType === 'function') {
+        throw new Error('Cannot convert function');
+    }
+
+    const jsType = EVAL_TYPE_TO_JS_TYPE[evalType];
+
+    let type: string = typeof val;
+    if (
+        jsType === 'array' && !Array.isArray(val) ||
+        jsType !== 'array' && type !== jsType ||
+        type === 'object' && val === null
+    ) {
+        if (type === 'object') {
+            if (Array.isArray(val)) {
+                type = 'array';
+            } else if (val === null) {
+                type = 'null';
+            } else {
+                type = 'dict';
+            }
+        }
+        throw new Error(`Incorrect value type: expected ${typeToString(evalType)}, got ${typeToString(type)}.`);
+    }
+    if (jsType === 'number' && evalType === 'integer') {
+        if (ctx) {
+            checkIntegerOverflow(ctx, val as number);
+        }
+        try {
+            val = toBigInt(val as number);
+        } catch (_err) {
+            throw new Error('Cannot convert value to integer.');
+        }
+    }
+    if (jsType === 'string' && evalType === 'color') {
+        val = transformColorValue(val as string);
+    }
+    if (jsType === 'string' && evalType === 'url') {
+        checkUrl(val);
+    }
+    if (jsType === 'boolean' && evalType === BOOLEAN) {
+        val = val ? 1 : 0;
+    }
+
+    return {
+        type: evalType,
+        value: val
+    } as EvalValue;
+}
+
+export function convertDivKitValueToJson(value: EvalValue) {
+    if (value.type === 'number' || value.type === 'integer') {
+        return Number(value.value);
+    } else if (value.type === 'boolean') {
+        return Boolean(value.value);
+    }
+
+    return value.value;
+}
+
+export function convertTypedValue(value: MaybeMissing<TypedValue>) {
+    return convertDivKitValueToJson(
+        convertJsValueToDivKit(undefined, value.value, value.type as EvalTypesWithoutDatetime)
+    );
+}

package/src/expressions/variable.ts

@@ -0,0 +1,429 @@
+// Adapted from Web implementation - replaced Svelte stores with Observable
+import type { Writable, Subscriber, Unsubscriber } from '../stores/createObservable';
+import { writable } from '../stores/createObservable';
+import type { EvalValue } from './eval';
+import { parseColor } from '../utils/correctColor';
+import { bigIntZero, toBigInt } from './bigint';
+import { checkUrl, transformColorValue } from './utils';
+import { BOOLEAN } from './const';
+
+export type VariableType = 'string' | 'number' | 'integer' | 'boolean' | 'color' | 'url' | 'dict' | 'array';
+export type VariableValue = string | number | bigint | boolean | null | undefined | object | unknown[];
+
+export abstract class Variable<
+    ValueType extends ConvertedSetValue = any,
+    TypeName = VariableType,
+    ConvertedSetValue = ValueType
+> {
+    protected name: string;
+    protected value: ValueType;
+    protected store?: Writable<ValueType>;
+
+    constructor(name: string, value: ConvertedSetValue) {
+        const val = this.convertValue(value);
+
+        this.name = name;
+        this.value = val;
+    }
+
+    getName(): string {
+        return this.name;
+    }
+
+    protected abstract convertValue(value: unknown): ValueType;
+
+    subscribe(cb: Subscriber<ValueType>): Unsubscriber {
+        if (!this.store) {
+            this.store = writable(this.value);
+        }
+
+        return this.store.subscribe(cb);
+    }
+
+    set(val: string): void {
+        const value = this.fromString(val);
+
+        this.setValue(value);
+    }
+
+    protected abstract fromString(val: string): ValueType;
+
+    setValue(val: ConvertedSetValue): void {
+        const converted = this.convertValue(val);
+
+        this.value = converted;
+
+        if (this.store) {
+            this.store.set(converted);
+        }
+    }
+
+    getValue(): ValueType {
+        return this.value;
+    }
+
+    abstract getType(): TypeName;
+}
+
+export class StringVariable extends Variable<string, 'string'> {
+    protected convertValue(value: unknown) {
+        if (typeof value !== 'string') {
+            throw new Error('Incorrect variable value');
+        }
+        return value;
+    }
+
+    protected fromString(val: string) {
+        return val;
+    }
+
+    getType(): 'string' {
+        return 'string';
+    }
+}
+
+export class IntegerVariable extends Variable<bigint, 'integer', bigint | number> {
+    protected convertValue(value: unknown) {
+        if (typeof value !== 'bigint' && typeof value !== 'number') {
+            throw new Error('Incorrect variable value');
+        }
+
+        try {
+            return toBigInt(value);
+        } catch (_err) {
+            throw new Error('Incorrect variable value');
+        }
+    }
+
+    protected fromString(val: string) {
+        try {
+            return toBigInt(val);
+        } catch (_err) {
+            throw new Error('Incorrect variable value');
+        }
+    }
+
+    getType(): 'integer' {
+        return 'integer';
+    }
+}
+
+export class NumberVariable extends Variable<number, 'number'> {
+    protected convertValue(value: unknown) {
+        if (
+            typeof value !== 'number' ||
+            Number.isNaN(value) ||
+            !isFinite(value)
+        ) {
+            throw new Error('Incorrect variable value');
+        }
+
+        return value;
+    }
+
+    protected fromString(val: string) {
+        const res = Number(val);
+
+        return this.convertValue(res);
+    }
+
+    getType(): 'number' {
+        return 'number';
+    }
+}
+
+export class BooleanVariable extends Variable<boolean, 'boolean'> {
+    protected convertValue(value: unknown) {
+        if (value !== 1 && value !== 0 && value !== true && value !== false) {
+            throw new Error('Incorrect variable value');
+        }
+
+        return Boolean(value);
+    }
+
+    protected fromString(val: string) {
+        if (val === '1' || val === 'true') {
+            return true;
+        } else if (val === '0' || val === 'false') {
+            return false;
+        }
+
+        throw new Error('Incorrect variable value');
+    }
+
+    getType(): 'boolean' {
+        return 'boolean';
+    }
+}
+
+export class ColorVariable extends Variable<string, 'color'> {
+    protected convertValue(value: unknown) {
+        if (typeof value !== 'string' || !parseColor(value)) {
+            throw new Error('Incorrect variable value');
+        }
+
+        return transformColorValue(value);
+    }
+
+    protected fromString(val: string) {
+        return this.convertValue(val);
+    }
+
+    getType(): 'color' {
+        return 'color';
+    }
+}
+
+export class UrlVariable extends Variable<string, 'url'> {
+    protected convertValue(value: unknown) {
+        if (typeof value !== 'string') {
+            throw new Error('Incorrect variable value');
+        }
+        checkUrl(value);
+
+        return value;
+    }
+
+    protected fromString(val: string) {
+        checkUrl(val);
+
+        return val;
+    }
+
+    getType(): 'url' {
+        return 'url';
+    }
+}
+
+export class DictVariable extends Variable<object, 'dict'> {
+    protected convertValue(value: unknown) {
+        if (typeof value !== 'object' || !value) {
+            throw new Error('Incorrect variable value');
+        }
+
+        return value;
+    }
+
+    protected fromString(val: string): object {
+        try {
+            return JSON.parse(val);
+        } catch (_err) {
+            throw new Error('Incorrect dict value');
+        }
+    }
+
+    getType(): 'dict' {
+        return 'dict';
+    }
+}
+
+export class ArrayVariable extends Variable<unknown[], 'array'> {
+    protected convertValue(value: unknown[]) {
+        if (!Array.isArray(value)) {
+            throw new Error('Incorrect variable value');
+        }
+
+        return value;
+    }
+
+    protected fromString(val: string): unknown[] {
+        try {
+            return JSON.parse(val);
+        } catch (_err) {
+            throw new Error('Incorrect array value');
+        }
+    }
+
+    getType(): 'array' {
+        return 'array';
+    }
+}
+
+export const TYPE_TO_CLASS: Record<VariableType, new (name: string, value: any) => Variable> = {
+    string: StringVariable,
+    number: NumberVariable,
+    integer: IntegerVariable,
+    boolean: BooleanVariable,
+    color: ColorVariable,
+    url: UrlVariable,
+    dict: DictVariable,
+    array: ArrayVariable
+};
+
+export function createVariable(
+    name: string,
+    type: VariableType,
+    value: unknown
+): Variable {
+    if (!(type in TYPE_TO_CLASS)) {
+        throw new Error('Unsupported variable type');
+    }
+
+    return new (TYPE_TO_CLASS[type] as any)(name, value);
+}
+
+// eslint-disable-next-line @typescript-eslint/no-empty-function
+function noop(): void {
+}
+
+function constSubscribe<ValueType>(this: Variable<ValueType>, cb: Subscriber<ValueType>): Unsubscriber {
+    cb(this.value);
+
+    return noop;
+}
+
+function constSetter(): void {
+    throw new Error('Cannot change the value of this type of variable');
+}
+
+class ConstStringVariable extends StringVariable {}
+class ConstNumberVariable extends NumberVariable {}
+class ConstIntegerVariable extends IntegerVariable {}
+class ConstBooleanVariable extends BooleanVariable {}
+class ConstColorVariable extends ColorVariable {}
+class ConstUrlVariable extends UrlVariable {}
+class ConstDictVariable extends DictVariable {}
+class ConstArrayVariable extends ArrayVariable {}
+
+class ConstDatetimeVariable extends Variable<Date, 'datetime'> {
+    protected convertValue(value: unknown) {
+        if (!(value instanceof Date)) {
+            throw new Error('Incorrect variable value');
+        }
+
+        return value;
+    }
+
+    protected fromString(): never {
+        throw new Error('Datetime variable does not support setter from string');
+    }
+
+    getType(): 'datetime' {
+        return 'datetime';
+    }
+}
+
+export const CONST_TYPE_TO_CLASS: {
+    string: typeof StringVariable;
+    number: typeof NumberVariable;
+    integer: typeof IntegerVariable;
+    boolean: typeof BooleanVariable;
+    color: typeof ColorVariable;
+    url: typeof UrlVariable;
+    dict: typeof DictVariable;
+    array: typeof ArrayVariable;
+    datetime: typeof ConstDatetimeVariable;
+} = {
+    string: ConstStringVariable,
+    number: ConstNumberVariable,
+    integer: ConstIntegerVariable,
+    boolean: ConstBooleanVariable,
+    color: ConstColorVariable,
+    url: ConstUrlVariable,
+    dict: ConstDictVariable,
+    array: ConstArrayVariable,
+    datetime: ConstDatetimeVariable
+} as any;
+
+for (const type in CONST_TYPE_TO_CLASS) {
+    const Class = CONST_TYPE_TO_CLASS[type as keyof typeof CONST_TYPE_TO_CLASS];
+
+    Class.prototype.subscribe = constSubscribe;
+    Class.prototype.set = constSetter;
+    Class.prototype.setValue = constSetter;
+}
+
+export function createConstVariable(
+    name: string,
+    type: VariableType | 'datetime',
+    value: unknown
+): Variable {
+    if (!(type in CONST_TYPE_TO_CLASS)) {
+        throw new Error('Unsupported variable type');
+    }
+
+    return new (CONST_TYPE_TO_CLASS[type] as any)(name, value);
+}
+
+export function defaultValueByType(type: keyof typeof TYPE_TO_CLASS): VariableValue {
+    if (type === 'integer') {
+        return bigIntZero;
+    }
+    if (type === 'boolean' || type === 'number') {
+        return 0;
+    }
+    if (type === 'dict') {
+        return {};
+    }
+    if (type === 'array') {
+        return [];
+    }
+
+    return '';
+}
+
+export function variableToValue(variable: Variable): EvalValue {
+    const type = variable.getType();
+    let value = variable.getValue();
+
+    if (type === BOOLEAN) {
+        value = value ? 1 : 0;
+    }
+
+    return {
+        type,
+        value
+    };
+}
+
+export function variableValueFromString(val: string, type: VariableType): VariableValue {
+    if (type === 'string') {
+        return val;
+    } else if (type === 'integer') {
+        try {
+            return toBigInt(val);
+        } catch (_err) {
+            throw new Error('Incorrect variable value');
+        }
+    } else if (type === 'number') {
+        const converted = Number(val);
+        if (
+            Number.isNaN(converted) ||
+            !isFinite(converted)
+        ) {
+            throw new Error('Incorrect variable value');
+        }
+
+        return converted;
+    } else if (type === 'boolean') {
+        if (val === '1' || val === 'true') {
+            return true;
+        } else if (val === '0' || val === 'false') {
+            return false;
+        }
+
+        throw new Error('Incorrect variable value');
+    } else if (type === 'color') {
+        if (typeof val !== 'string' || !parseColor(val)) {
+            throw new Error('Incorrect variable value');
+        }
+
+        return transformColorValue(val);
+    } else if (type === 'url') {
+        if (typeof val !== 'string') {
+            throw new Error('Incorrect variable value');
+        }
+        checkUrl(val);
+
+        return val;
+    } else if (type === 'dict' || type === 'array') {
+        try {
+            return JSON.parse(val);
+        } catch (_err) {
+            throw new Error('Incorrect dict value');
+        }
+    }
+
+    // For purpose when new eval value types will be added
+    throw new Error(`Unexpected type ${type}`);
+}