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

package/src/actions/array.ts

@@ -1,4 +1,9 @@
-import type { ActionArrayInsertValue, ActionArrayRemoveValue, ActionArraySetValue, WrappedError } from '../../typings/common';
+import type {
+    ActionArrayInsertValue,
+    ActionArrayRemoveValue,
+    ActionArraySetValue,
+    WrappedError
+} from '../../typings/common';
 import type { ArrayVariable, Variable } from '../../typings/variables';
 import type { MaybeMissing } from '../expressions/json';
 import { convertTypedValue } from '../expressions/utils';
@@ -13,31 +18,37 @@ export function arrayInsert(
 ): void {
     const { variable_name: name, index, value } = actionTyped;
 
-    if (!value || typeof index !== 'number' && index !== undefined) {
-        logError(wrapError(new Error('Incorrect array_insert_value action'), {
-            additional: {
-                name
-            }
-        }));
+    if (!value || (typeof index !== 'number' && index !== undefined)) {
+        logError(
+            wrapError(new Error('Incorrect array_insert_value action'), {
+                additional: {
+                    name
+                }
+            })
+        );
         return;
     }
 
     handle(componentContext, variables, logError, actionTyped, variableInstance => {
         const list = variableInstance.getValue();
         if (typeof index === 'number' && (index < 0 || index > list.length)) {
-            logError(wrapError(new Error(`Index out of bound for mutation ${actionTyped.type}`), {
-                additional: {
-                    name,
-                    index,
-                    length: list.length
-                }
-            }));
+            logError(
+                wrapError(new Error(`Index out of bound for mutation ${actionTyped.type}`), {
+                    additional: {
+                        name,
+                        index,
+                        length: list.length
+                    }
+                })
+            );
         } else if (!value.type) {
-            logError(wrapError(new Error('Incorrect value type'), {
-                additional: {
-                    name
-                }
-            }));
+            logError(
+                wrapError(new Error('Incorrect value type'), {
+                    additional: {
+                        name
+                    }
+                })
+            );
         } else {
             const newList = list.slice();
             const val = convertTypedValue(value);
@@ -60,24 +71,28 @@ export function arrayRemove(
     const { variable_name: name, index } = actionTyped;
 
     if (typeof index !== 'number') {
-        logError(wrapError(new Error('Incorrect array_remove_value action'), {
-            additional: {
-                name
-            }
-        }));
+        logError(
+            wrapError(new Error('Incorrect array_remove_value action'), {
+                additional: {
+                    name
+                }
+            })
+        );
         return;
     }
 
     handle(componentContext, variables, logError, actionTyped, variableInstance => {
         const list = variableInstance.getValue();
         if (typeof index === 'number' && (index < 0 || index >= list.length)) {
-            logError(wrapError(new Error(`Index out of bound for mutation ${actionTyped.type}`), {
-                additional: {
-                    name,
-                    index,
-                    length: list.length
-                }
-            }));
+            logError(
+                wrapError(new Error(`Index out of bound for mutation ${actionTyped.type}`), {
+                    additional: {
+                        name,
+                        index,
+                        length: list.length
+                    }
+                })
+            );
         } else {
             const newList = list.slice();
             newList.splice(index, 1);
@@ -95,30 +110,36 @@ export function arraySet(
     const { variable_name: name, index, value } = actionTyped;
 
     if (!value || typeof index !== 'number') {
-        logError(wrapError(new Error('Incorrect array_set_value action'), {
-            additional: {
-                name
-            }
-        }));
+        logError(
+            wrapError(new Error('Incorrect array_set_value action'), {
+                additional: {
+                    name
+                }
+            })
+        );
         return;
     }
 
     handle(componentContext, variables, logError, actionTyped, variableInstance => {
         const list = variableInstance.getValue();
         if (typeof index === 'number' && (index < 0 || index >= list.length)) {
-            logError(wrapError(new Error(`Index out of bound for mutation ${actionTyped.type}`), {
-                additional: {
-                    name,
-                    index,
-                    length: list.length
-                }
-            }));
+            logError(
+                wrapError(new Error(`Index out of bound for mutation ${actionTyped.type}`), {
+                    additional: {
+                        name,
+                        index,
+                        length: list.length
+                    }
+                })
+            );
         } else if (!value.type) {
-            logError(wrapError(new Error('Incorrect value type'), {
-                additional: {
-                    name
-                }
-            }));
+            logError(
+                wrapError(new Error('Incorrect value type'), {
+                    additional: {
+                        name
+                    }
+                })
+            );
         } else {
             const newList = list.slice();
             newList[index] = convertTypedValue(value);
@@ -137,22 +158,26 @@ function handle(
     const { variable_name: name } = actionTyped;
 
     if (!name) {
-        logError(wrapError(new Error(`Incorrect ${actionTyped.type} action`), {
-            additional: {
-                name
-            }
-        }));
+        logError(
+            wrapError(new Error(`Incorrect ${actionTyped.type} action`), {
+                additional: {
+                    name
+                }
+            })
+        );
         return;
     }
 
     const variableInstance = componentContext?.getVariable(name) || variables.get(name);
 
     if (!variableInstance) {
-        logError(wrapError(new Error('Cannot find variable'), {
-            additional: {
-                name
-            }
-        }));
+        logError(
+            wrapError(new Error('Cannot find variable'), {
+                additional: {
+                    name
+                }
+            })
+        );
         return;
     }
 
@@ -160,11 +185,13 @@ function handle(
     if (type === 'array') {
         cb(variableInstance as ArrayVariable);
     } else {
-        logError(wrapError(new Error('Trying to insert value into the non-array'), {
-            additional: {
-                name,
-                type
-            }
-        }));
+        logError(
+            wrapError(new Error('Trying to insert value into the non-array'), {
+                additional: {
+                    name,
+                    type
+                }
+            })
+        );
     }
 }

package/src/actions/copyToClipboard.ts

@@ -44,15 +44,20 @@ export function copyToClipboard(
     logError: (error: WrappedError) => void,
     actionTyped: MaybeMissing<ActionCopyToClipboard>
 ): void {
-    if (!(
-        actionTyped.content && (actionTyped.content.type === 'text' || actionTyped.content.type === 'url') &&
-        typeof actionTyped.content.value === 'string'
-    )) {
-        logError(wrapError(new Error('Incorrect action'), {
-            additional: {
-                action: actionTyped
-            }
-        }));
+    if (
+        !(
+            actionTyped.content &&
+            (actionTyped.content.type === 'text' || actionTyped.content.type === 'url') &&
+            typeof actionTyped.content.value === 'string'
+        )
+    ) {
+        logError(
+            wrapError(new Error('Incorrect action'), {
+                additional: {
+                    action: actionTyped
+                }
+            })
+        );
         return;
     }
 
@@ -62,21 +67,25 @@ export function copyToClipboard(
     }
 
     if (!Clipboard) {
-        logError(wrapError(new Error('Clipboard is unavailable. Install @react-native-clipboard/clipboard'), {
-            additional: {
-                action: actionTyped
-            }
-        }));
+        logError(
+            wrapError(new Error('Clipboard is unavailable. Install @react-native-clipboard/clipboard'), {
+                additional: {
+                    action: actionTyped
+                }
+            })
+        );
         return;
     }
 
     try {
         Clipboard.setString(actionTyped.content.value);
     } catch (err) {
-        logError(wrapError(new Error('Failed to copy to the clipboard'), {
-            additional: {
-                originalError: String(err)
-            }
-        }));
+        logError(
+            wrapError(new Error('Failed to copy to the clipboard'), {
+                additional: {
+                    originalError: String(err)
+                }
+            })
+        );
     }
 }

package/src/actions/dict.ts

@@ -14,39 +14,47 @@ export function dictSetValue(
     const { variable_name: name, key, value } = actionTyped;
 
     if (typeof key !== 'string') {
-        logError(wrapError(new Error('Incorrect dict_set_value action'), {
-            additional: {
-                name
-            }
-        }));
+        logError(
+            wrapError(new Error('Incorrect dict_set_value action'), {
+                additional: {
+                    name
+                }
+            })
+        );
         return;
     }
 
     if (!name) {
-        logError(wrapError(new Error(`Incorrect ${actionTyped.type} action`), {
-            additional: {
-                name
-            }
-        }));
+        logError(
+            wrapError(new Error(`Incorrect ${actionTyped.type} action`), {
+                additional: {
+                    name
+                }
+            })
+        );
         return;
     }
 
     if (value && !value.type) {
-        logError(wrapError(new Error('Incorrect value type'), {
-            additional: {
-                name
-            }
-        }));
+        logError(
+            wrapError(new Error('Incorrect value type'), {
+                additional: {
+                    name
+                }
+            })
+        );
     }
 
     const variableInstance = componentContext?.getVariable(name) || variables.get(name);
 
     if (!variableInstance) {
-        logError(wrapError(new Error('Cannot find variable'), {
-            additional: {
-                name
-            }
-        }));
+        logError(
+            wrapError(new Error('Cannot find variable'), {
+                additional: {
+                    name
+                }
+            })
+        );
         return;
     }
 
@@ -61,11 +69,13 @@ export function dictSetValue(
         }
         variableInstance.setValue(newDict);
     } else {
-        logError(wrapError(new Error('Trying to set value into the non-dict'), {
-            additional: {
-                name,
-                type
-            }
-        }));
+        logError(
+            wrapError(new Error('Trying to set value into the non-dict'), {
+                additional: {
+                    name,
+                    type
+                }
+            })
+        );
     }
 }

package/src/actions/updateStructure.ts

@@ -14,40 +14,48 @@ export function updateStructure(
     const { variable_name: name, path, value } = actionTyped;
 
     if (!value?.value) {
-        logError(wrapError(new Error('Missing value for an action'), {
-            additional: {
-                name
-            }
-        }));
+        logError(
+            wrapError(new Error('Missing value for an action'), {
+                additional: {
+                    name
+                }
+            })
+        );
         return;
     }
 
     if (typeof path !== 'string' || !path || path.charAt(0) === '/' || path.charAt(path.length - 1) === '/') {
-        logError(wrapError(new Error(`Value '${path}' for key 'path' is not valid`), {
-            additional: {
-                name
-            }
-        }));
+        logError(
+            wrapError(new Error(`Value '${path}' for key 'path' is not valid`), {
+                additional: {
+                    name
+                }
+            })
+        );
         return;
     }
 
     if (!name) {
-        logError(wrapError(new Error(`Incorrect ${actionTyped.type} action`), {
-            additional: {
-                name
-            }
-        }));
+        logError(
+            wrapError(new Error(`Incorrect ${actionTyped.type} action`), {
+                additional: {
+                    name
+                }
+            })
+        );
         return;
     }
 
     const variableInstance = componentContext?.getVariable(name) || variables.get(name);
 
     if (!variableInstance) {
-        logError(wrapError(new Error('Cannot find variable'), {
-            additional: {
-                name
-            }
-        }));
+        logError(
+            wrapError(new Error('Cannot find variable'), {
+                additional: {
+                    name
+                }
+            })
+        );
         return;
     }
 
@@ -56,13 +64,15 @@ export function updateStructure(
         const obj = variableInstance.getValue() as Record<string, unknown>;
         const processed = path.replace(/\/+/g, '/');
         if (processed === '/') {
-            logError(wrapError(new Error(`Value '${path}' for key 'path' is not valid`), {
-                additional: {
-                    name,
-                    type,
-                    path
-                }
-            }));
+            logError(
+                wrapError(new Error(`Value '${path}' for key 'path' is not valid`), {
+                    additional: {
+                        name,
+                        type,
+                        path
+                    }
+                })
+            );
             return;
         }
         const parts = processed.split('/');
@@ -72,46 +82,59 @@ export function updateStructure(
             const part = parts[i];
 
             if (!part) {
-                logError(wrapError(new Error('Path is empty'), {
-                    additional: {
-                        name,
-                        type,
-                        path
-                    }
-                }));
+                logError(
+                    wrapError(new Error('Path is empty'), {
+                        additional: {
+                            name,
+                            type,
+                            path
+                        }
+                    })
+                );
                 return;
             }
 
             if (!temp || typeof temp !== 'object') {
-                logError(wrapError(new Error(`Element with path '${parts.slice(0, i).join('/')}' is not ${temp === undefined ? 'found' : 'a structure'}`), {
-                    additional: {
-                        name,
-                        type,
-                        path
-                    }
-                }));
+                logError(
+                    wrapError(
+                        new Error(
+                            `Element with path '${parts.slice(0, i).join('/')}' is not ${temp === undefined ? 'found' : 'a structure'}`
+                        ),
+                        {
+                            additional: {
+                                name,
+                                type,
+                                path
+                            }
+                        }
+                    )
+                );
                 return;
             }
             if (Array.isArray(temp)) {
                 const int = Number(part);
                 if (Number.isNaN(int)) {
-                    logError(wrapError(new Error(`Unable to use '${part}' as array index`), {
-                        additional: {
-                            name,
-                            type,
-                            path
-                        }
-                    }));
+                    logError(
+                        wrapError(new Error(`Unable to use '${part}' as array index`), {
+                            additional: {
+                                name,
+                                type,
+                                path
+                            }
+                        })
+                    );
                     return;
                 }
                 if (i + 1 === parts.length && (int < 0 || int > temp.length)) {
-                    logError(wrapError(new Error(`Position '${int}' is out of array bounds`), {
-                        additional: {
-                            name,
-                            type,
-                            path
-                        }
-                    }));
+                    logError(
+                        wrapError(new Error(`Position '${int}' is out of array bounds`), {
+                            additional: {
+                                name,
+                                type,
+                                path
+                            }
+                        })
+                    );
                     return;
                 }
             }
@@ -124,11 +147,13 @@ export function updateStructure(
         temp[parts[parts.length - 1]] = convertTypedValue(value);
         variableInstance.setValue(newObj);
     } else {
-        logError(wrapError(new Error('Action requires array or dictionary variable'), {
-            additional: {
-                name,
-                type
-            }
-        }));
+        logError(
+            wrapError(new Error('Action requires array or dictionary variable'), {
+                additional: {
+                    name,
+                    type
+                }
+            })
+        );
     }
 }