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

package/src/stores/createObservable.ts

@@ -7,46 +7,46 @@ export type Subscriber<T> = (value: T) => void;
 export type Unsubscriber = () => void;
 
 export class Observable<T> {
-  private value: T;
-  private subscribers = new Set<Subscriber<T>>();
+    private value: T;
+    private subscribers = new Set<Subscriber<T>>();
 
-  constructor(initialValue: T) {
-    this.value = initialValue;
-  }
+    constructor(initialValue: T) {
+        this.value = initialValue;
+    }
 
-  /**
-   * Subscribe to value changes
-   * @param callback Function called immediately with current value and on each change
-   * @returns Unsubscribe function
-   */
-  subscribe(callback: Subscriber<T>): Unsubscriber {
-    this.subscribers.add(callback);
-    // Immediately call with current value (Svelte store behavior)
-    callback(this.value);
+    /**
+     * Subscribe to value changes
+     * @param callback Function called immediately with current value and on each change
+     * @returns Unsubscribe function
+     */
+    subscribe(callback: Subscriber<T>): Unsubscriber {
+        this.subscribers.add(callback);
+        // Immediately call with current value (Svelte store behavior)
+        callback(this.value);
 
-    return () => {
-      this.subscribers.delete(callback);
-    };
-  }
+        return () => {
+            this.subscribers.delete(callback);
+        };
+    }
 
-  /**
-   * Update the value and notify all subscribers
-   * @param newValue New value to set
-   */
-  set(newValue: T): void {
-    if (this.value !== newValue) {
-      this.value = newValue;
-      this.subscribers.forEach(cb => cb(newValue));
+    /**
+     * Update the value and notify all subscribers
+     * @param newValue New value to set
+     */
+    set(newValue: T): void {
+        if (this.value !== newValue) {
+            this.value = newValue;
+            this.subscribers.forEach(cb => cb(newValue));
+        }
     }
-  }
 
-  /**
-   * Get current value without subscribing
-   * @returns Current value
-   */
-  get(): T {
-    return this.value;
-  }
+    /**
+     * Get current value without subscribing
+     * @returns Current value
+     */
+    get(): T {
+        return this.value;
+    }
 }
 
 /**
@@ -55,7 +55,7 @@ export class Observable<T> {
  * @returns Observable instance
  */
 export function writable<T>(initialValue: T): Observable<T> {
-  return new Observable(initialValue);
+    return new Observable(initialValue);
 }
 
 /**

package/src/types/alignment.d.ts

@@ -3,11 +3,20 @@ export type AlignmentHorizontal = 'left' | 'center' | 'right' | 'start' | 'end';
 export type AlignmentVertical = 'top' | 'center' | 'bottom' | 'baseline';
 
 export type ContentAlignmentHorizontal =
-    'left' | 'center' | 'right' |
-    'start' | 'end' |
-    'space-between' | 'space-around' | 'space-evenly';
+    | 'left'
+    | 'center'
+    | 'right'
+    | 'start'
+    | 'end'
+    | 'space-between'
+    | 'space-around'
+    | 'space-evenly';
 
 export type ContentAlignmentVertical =
-    'top' | 'center' | 'bottom' |
-    'space-between' | 'space-around' | 'space-evenly' |
-    'baseline';
+    | 'top'
+    | 'center'
+    | 'bottom'
+    | 'space-between'
+    | 'space-around'
+    | 'space-evenly'
+    | 'baseline';

package/src/types/background.d.ts

@@ -67,5 +67,9 @@ export interface RadialBackground {
     center_y?: RadialGradientCenter;
 }
 
-export type Background = GradientBackground | ImageBackground |
-    SolidBackground | RadialBackground | NinePatchImageBackground;
+export type Background =
+    | GradientBackground
+    | ImageBackground
+    | SolidBackground
+    | RadialBackground
+    | NinePatchImageBackground;

package/src/types/base.d.ts

@@ -4,12 +4,34 @@ import type { Border } from './border';
 import type { Background } from './background';
 import type { EdgeInsets } from './edgeInserts';
 import type { Dimension } from './sizes';
-import type { Action, AnimatorDirection, AnimatorRepeatCount, BooleanInt, DisappearAction, DivFunction, DivVariable, Interpolation, VariableTrigger, VisibilityAction } from '../../typings/common';
+import type {
+    Action,
+    AnimatorDirection,
+    AnimatorRepeatCount,
+    BooleanInt,
+    DisappearAction,
+    DivFunction,
+    DivVariable,
+    Interpolation,
+    VariableTrigger,
+    VisibilityAction
+} from '../../typings/common';
 import type { Focus } from './focus';
 import type { Animation } from './animation';
 
-export type AccessibilityType = 'none' | 'button' | 'image' | 'text' | 'edit_text' |
-    'header' | 'tab_bar' | 'list' | 'select' | 'checkbox' | 'radio' | 'auto';
+export type AccessibilityType =
+    | 'none'
+    | 'button'
+    | 'image'
+    | 'text'
+    | 'edit_text'
+    | 'header'
+    | 'tab_bar'
+    | 'list'
+    | 'select'
+    | 'checkbox'
+    | 'radio'
+    | 'auto';
 
 export type AccessibilityMode = 'default' | 'merge' | 'exclude';
 
@@ -64,10 +86,12 @@ export interface ChangeBoundsTransition extends TransitionBase {
     type: 'change_bounds';
 }
 
-export type TransitionChange = ChangeBoundsTransition | {
-    type: 'set';
-    items: TransitionChange[];
-}
+export type TransitionChange =
+    | ChangeBoundsTransition
+    | {
+          type: 'set';
+          items: TransitionChange[];
+      };
 
 export interface PivotFixedValue {
     type: 'pivot-fixed';
@@ -133,8 +157,16 @@ export type TooltipMode = TooltipModeModal | TooltipModeNonModal;
 export interface Tooltip {
     id: string;
     div: DivBaseData;
-    position: 'left' | 'top-left' | 'top' | 'top-right' | 'right' |
-        'bottom-right' | 'bottom' | 'bottom-left' | 'center';
+    position:
+        | 'left'
+        | 'top-left'
+        | 'top'
+        | 'top-right'
+        | 'right'
+        | 'bottom-right'
+        | 'bottom'
+        | 'bottom-left'
+        | 'center';
     duration?: number;
     offset?: {
         x: {

package/src/types/componentContext.d.ts

@@ -28,10 +28,12 @@ export interface PagerRegisterData {
     destroy: () => void;
 }
 
-export type ComponentKey = string | {
-    index: number;
-    data: object;
-};
+export type ComponentKey =
+    | string
+    | {
+          index: number;
+          data: object;
+      };
 
 export interface ComponentContext<T extends DivBaseData = DivBaseData> {
     path: string[];
@@ -70,24 +72,27 @@ export interface ComponentContext<T extends DivBaseData = DivBaseData> {
         keepComplex?: boolean,
         maxDepth?: number
     ): Readable<MaybeMissing<T>>;
-    getJsonWithVars<T>(
-        jsonProp: T,
-        additionalVars?: Map<string, Variable>,
-        keepComplex?: boolean
-    ): MaybeMissing<T>;
-    evalExpression(store: Store | undefined, expr: Node, opts?: {
-        weekStartDay?: number;
-        storeUsedVars?: Set<string>;
-    }): ReturnType<typeof evalExpression>;
-    produceChildContext(div: MaybeMissing<DivBaseData>, opts?: {
-        path?: string | number | undefined;
-        isRootState?: boolean;
-        isTooltipRoot?: boolean;
-        fake?: number;
-        variables?: Map<string, Variable>;
-        id?: string;
-        key?: ComponentKey;
-    }): ComponentContext;
+    getJsonWithVars<T>(jsonProp: T, additionalVars?: Map<string, Variable>, keepComplex?: boolean): MaybeMissing<T>;
+    evalExpression(
+        store: Store | undefined,
+        expr: Node,
+        opts?: {
+            weekStartDay?: number;
+            storeUsedVars?: Set<string>;
+        }
+    ): ReturnType<typeof evalExpression>;
+    produceChildContext(
+        div: MaybeMissing<DivBaseData>,
+        opts?: {
+            path?: string | number | undefined;
+            isRootState?: boolean;
+            isTooltipRoot?: boolean;
+            fake?: number;
+            variables?: Map<string, Variable>;
+            id?: string;
+            key?: ComponentKey;
+        }
+    ): ComponentContext;
     dup(fakeReason: number): ComponentContext;
     getVariable(varName: string, type?: VariableType): Variable | undefined;
     getAnimator(name: string): MaybeMissing<Animator> | undefined;

package/src/types/container.d.ts

@@ -1,9 +1,6 @@
 import type { DivBaseData } from './base';
 import type { DivActionableData } from './actionable';
-import type {
-    ContentAlignmentHorizontal,
-    ContentAlignmentVertical
-} from './alignment';
+import type { ContentAlignmentHorizontal, ContentAlignmentVertical } from './alignment';
 import type { BooleanInt } from '../../typings/common';
 import type { Drawable } from './drawable';
 import type { DivAspect } from './image';

package/src/types/text.d.ts

@@ -57,7 +57,7 @@ export interface TextMaskParticles {
     density?: number;
 }
 
-export interface TextMaskSolid{
+export interface TextMaskSolid {
     type: 'solid';
     is_enabled?: boolean;
     color: string;

package/src/utils/applyTemplate.ts

@@ -1,145 +1,139 @@
-import type { WrappedError } from "./wrapError";
-import type { DivBase, TemplateContext } from "../../typings/common";
-import type { DivBaseData } from "../types/base";
+import type { WrappedError } from './wrapError';
+import type { DivBase, TemplateContext } from '../../typings/common';
+import type { DivBaseData } from '../types/base';
 
 export function applyTemplate<T extends DivBase>(
-  json: T,
-  templateContext: TemplateContext,
-  templates: Record<string, unknown>,
-  _logError: (error: WrappedError) => void,
+    json: T,
+    templateContext: TemplateContext,
+    templates: Record<string, unknown>,
+    _logError: (error: WrappedError) => void
 ): {
-  json: T;
-  templateContext: TemplateContext;
+    json: T;
+    templateContext: TemplateContext;
 };
 export function applyTemplate(
-  json: DivBaseData,
-  templateContext: TemplateContext,
-  templates: Record<string, unknown>,
-  _logError: (error: WrappedError) => void,
+    json: DivBaseData,
+    templateContext: TemplateContext,
+    templates: Record<string, unknown>,
+    _logError: (error: WrappedError) => void
 ): {
-  json: DivBaseData;
-  templateContext: TemplateContext;
+    json: DivBaseData;
+    templateContext: TemplateContext;
 } {
-  const template = templates[json.type];
-
-  if (!template) {
-    // If template is missing, treat it as a standard component
-    return {
-      json,
-      templateContext,
-    };
-  }
+    const template = templates[json.type];
+
+    if (!template) {
+        // If template is missing, treat it as a standard component
+        return {
+            json,
+            templateContext
+        };
+    }
 
-  let i;
-  const newContext: TemplateContext = {};
+    let i;
+    const newContext: TemplateContext = {};
 
-  for (i in templateContext) {
-    if (Object.prototype.hasOwnProperty.call(templateContext, i)) {
-      newContext[i] = templateContext[i];
+    for (i in templateContext) {
+        if (Object.prototype.hasOwnProperty.call(templateContext, i)) {
+            newContext[i] = templateContext[i];
+        }
     }
-  }
 
-  for (i in json) {
-    if (i === "type" || i === "__proto__") {
-      continue;
-    }
+    for (i in json) {
+        if (i === 'type' || i === '__proto__') {
+            continue;
+        }
 
-    if (Object.prototype.hasOwnProperty.call(json, i)) {
-      newContext[i] = json[i as keyof typeof json];
+        if (Object.prototype.hasOwnProperty.call(json, i)) {
+            newContext[i] = json[i as keyof typeof json];
+        }
     }
-  }
 
-  function copyTemplated(base: any, extender: any) {
-    const keys = Object.keys(extender).filter((key) => key !== "__proto__");
-    const simpleKeys = keys.filter((key) => key.charAt(0) !== "$");
-    const templateKeys = keys.filter((key) => key.charAt(0) === "$");
+    function copyTemplated(base: any, extender: any) {
+        const keys = Object.keys(extender).filter(key => key !== '__proto__');
+        const simpleKeys = keys.filter(key => key.charAt(0) !== '$');
+        const templateKeys = keys.filter(key => key.charAt(0) === '$');
 
-    simpleKeys.forEach((key) => {
-      const item = extender[key];
+        simpleKeys.forEach(key => {
+            const item = extender[key];
 
-      if (typeof item === "object" && item !== null) {
-        base[key] = Array.isArray(item) ? [] : {};
-        copyTemplated(base[key], item);
-      } else {
-        base[key] = item;
-      }
-    });
+            if (typeof item === 'object' && item !== null) {
+                base[key] = Array.isArray(item) ? [] : {};
+                copyTemplated(base[key], item);
+            } else {
+                base[key] = item;
+            }
+        });
 
-    templateKeys.forEach((key) => {
-      const item = extender[key];
+        templateKeys.forEach(key => {
+            const item = extender[key];
 
-      const val = newContext[item];
+            const val = newContext[item];
 
-      if (val !== undefined) {
-        const prop = key.substring(1);
-        base[prop] = val;
-      }
-    });
+            if (val !== undefined) {
+                const prop = key.substring(1);
+                base[prop] = val;
+            }
+        });
 
-    return base;
-  }
+        return base;
+    }
 
-  const newJson = copyTemplated({}, template);
+    const newJson = copyTemplated({}, template);
 
-  for (i in json) {
-    if (i === "type" || i === "__proto__") {
-      continue;
-    }
+    for (i in json) {
+        if (i === 'type' || i === '__proto__') {
+            continue;
+        }
 
-    if (Object.prototype.hasOwnProperty.call(json, i)) {
-      newJson[i] = json[i as keyof typeof json];
+        if (Object.prototype.hasOwnProperty.call(json, i)) {
+            newJson[i] = json[i as keyof typeof json];
+        }
     }
-  }
 
-  return {
-    json: newJson,
-    templateContext: newContext,
-  };
+    return {
+        json: newJson,
+        templateContext: newContext
+    };
 }
 
 export function applyTemplatesRecursively(
-  json: any,
-  templates: Record<string, unknown>,
-  logError: (error: WrappedError) => void,
+    json: any,
+    templates: Record<string, unknown>,
+    logError: (error: WrappedError) => void
 ): any {
-  if (!json || typeof json !== "object") {
-    return json;
-  }
-
-  if (Array.isArray(json)) {
-    return json.map((item) =>
-      applyTemplatesRecursively(item, templates, logError),
-    );
-  }
-
-  let resolvedJson = json;
-
-  // Attempt expansion if type matches a template
-  if (json.type && templates[json.type]) {
-    try {
-      const res = applyTemplate(json, {}, templates, logError);
-      resolvedJson = res.json;
-    } catch (_e) {
-      // Expansion failed
+    if (!json || typeof json !== 'object') {
+        return json;
+    }
+
+    if (Array.isArray(json)) {
+        return json.map(item => applyTemplatesRecursively(item, templates, logError));
     }
-  }
 
-  // Recursively process children
-  const result: any = {};
-  for (const key in resolvedJson) {
-    if (!Object.prototype.hasOwnProperty.call(resolvedJson, key)) continue;
+    let resolvedJson = json;
 
-    if (key === "type") {
-      result[key] = resolvedJson[key];
-      continue;
+    // Attempt expansion if type matches a template
+    if (json.type && templates[json.type]) {
+        try {
+            const res = applyTemplate(json, {}, templates, logError);
+            resolvedJson = res.json;
+        } catch (_e) {
+            // Expansion failed
+        }
     }
 
-    result[key] = applyTemplatesRecursively(
-      resolvedJson[key],
-      templates,
-      logError,
-    );
-  }
+    // Recursively process children
+    const result: any = {};
+    for (const key in resolvedJson) {
+        if (!Object.prototype.hasOwnProperty.call(resolvedJson, key)) continue;
+
+        if (key === 'type') {
+            result[key] = resolvedJson[key];
+            continue;
+        }
+
+        result[key] = applyTemplatesRecursively(resolvedJson[key], templates, logError);
+    }
 
-  return result;
+    return result;
 }

package/src/utils/correctColor.ts

@@ -8,7 +8,7 @@ import { padLeft } from './padLeft';
  * @returns Color with opacity if it has correct format, or defaultColor elsewhere
  */
 export function correctColor(color: string | undefined, alpha = 1, defaultColor = 'transparent'): string {
-    color = (typeof color === 'string' && color || '').toLowerCase();
+    color = ((typeof color === 'string' && color) || '').toLowerCase();
 
     if (color.charAt(0) !== '#') {
         return defaultColor;
@@ -24,7 +24,7 @@ export function correctColor(color: string | undefined, alpha = 1, defaultColor
 }
 
 export function correctColorWithAlpha(color: string | undefined, alpha: number, defaultColor = 'transparent'): string {
-    color = (typeof color === 'string' && color || '').toLowerCase();
+    color = ((typeof color === 'string' && color) || '').toLowerCase();
 
     if (color.charAt(0) !== '#') {
         return defaultColor;
@@ -48,16 +48,18 @@ export interface ParsedColor {
 
 export function stringifyColorToCss(color: ParsedColor): string {
     if (color.a === 255) {
-        return `#${[color.r, color.g, color.b].map(it => {
-            return padLeft(Math.round(it).toString(16), 2);
-        }).join('')}`;
+        return `#${[color.r, color.g, color.b]
+            .map(it => {
+                return padLeft(Math.round(it).toString(16), 2);
+            })
+            .join('')}`;
     }
 
     return `rgba(${color.r},${color.g},${color.b},${(color.a / 255).toFixed(2)})`;
 }
 
 export function parseColor(color: string): ParsedColor | null {
-    const colorMatch = (
+    const colorMatch =
         // #AARRGGBB
         color.match(/^#([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})$/i) ||
         // #ARGB
@@ -65,8 +67,7 @@ export function parseColor(color: string): ParsedColor | null {
         // #RRGGBB
         color.match(/^#([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})$/i) ||
         // #RGB
-        color.match(/^#([0-9a-f])([0-9a-f])([0-9a-f])$/i)
-    );
+        color.match(/^#([0-9a-f])([0-9a-f])([0-9a-f])$/i);
 
     if (colorMatch) {
         // with alpha part in color