@nordcraft/search 1.0.37 → 1.0.39

package/dist/rules/formulas/legacyFormulaRule.js

@@ -1,18 +1,606 @@
 import { isToddleFormula } from '@nordcraft/core/dist/formula/formulaTypes';
+import { omitKeys, set } from '@nordcraft/core/dist/utils/collections';
 import { isDefined } from '@nordcraft/core/dist/utils/util';
 export const legacyFormulaRule = {
     code: 'legacy formula',
     level: 'warning',
     category: 'Deprecation',
-    visit: (report, { path, files, value, nodeType }) => {
-        if (nodeType !== 'formula' ||
-            value.type !== 'function' ||
-            !isLegacyFormula(value, files)) {
+    visit: (report, data) => {
+        if (!isIssue(data)) {
             return;
         }
-        report(path, { name: value.name });
+        report(data.path, { name: data.value.name }, 
+        // The TYPE formula cannot be autofixed since the types have changed between the 2 implementations
+        data.value.name !== 'TYPE' ? ['replace-legacy-formula'] : undefined);
+    },
+    fixes: {
+        'replace-legacy-formula': (data) => {
+            if (!isIssue(data)) {
+                return;
+            }
+            switch (data.value.name) {
+                // Known legacy formulas first
+                case 'AND': {
+                    const { name, ...legacyAndFormula } = data.value;
+                    const andFormula = {
+                        ...legacyAndFormula,
+                        type: 'and',
+                        arguments: legacyAndFormula.arguments.map((a) => {
+                            const { name, ...argument } = a;
+                            return argument;
+                        }),
+                    };
+                    return set(data.files, data.path, andFormula);
+                }
+                case 'CONCAT': {
+                    const newConcatFormula = {
+                        ...data.value,
+                        name: '@toddle/concatenate',
+                        display_name: 'Concatenate',
+                    };
+                    return set(data.files, data.path, newConcatFormula);
+                }
+                case 'DEFAULT': {
+                    const newDefaultFormula = {
+                        ...data.value,
+                        name: '@toddle/defaultTo',
+                        // The old DEFAULT formula did not support variableArguments
+                        variableArguments: true,
+                        display_name: 'Default to',
+                    };
+                    return set(data.files, data.path, newDefaultFormula);
+                }
+                case 'DELETE': {
+                    const newDeleteFormula = {
+                        ...data.value,
+                        name: '@toddle/deleteKey',
+                        display_name: 'Delete',
+                    };
+                    return set(data.files, data.path, newDeleteFormula);
+                }
+                case 'DROP_LAST': {
+                    const newDropLastFormula = {
+                        ...data.value,
+                        name: '@toddle/dropLast',
+                        display_name: 'Drop Last',
+                        arguments: renameArguments(ARRAY_ARGUMENT_MAPPINGS, data.value.arguments),
+                    };
+                    return set(data.files, data.path, newDropLastFormula);
+                }
+                case 'EQ': {
+                    const newEqualsFormula = {
+                        ...data.value,
+                        name: '@toddle/equals',
+                        display_name: 'Equals',
+                    };
+                    return set(data.files, data.path, newEqualsFormula);
+                }
+                case 'FIND INDEX': {
+                    const newFindIndexFormula = {
+                        ...data.value,
+                        name: '@toddle/findIndex',
+                        display_name: 'Find index',
+                        arguments: renameArguments(PREDICATE_ARGUMENT_MAPPINGS, data.value.arguments),
+                    };
+                    return set(data.files, data.path, newFindIndexFormula);
+                }
+                case 'FLAT': {
+                    const newFlattenFormula = {
+                        ...data.value,
+                        name: '@toddle/flatten',
+                        display_name: 'Flatten',
+                        arguments: renameArguments(ARRAY_ARGUMENT_MAPPINGS, data.value.arguments),
+                    };
+                    return set(data.files, data.path, newFlattenFormula);
+                }
+                case 'GT': {
+                    const newGreaterThanFormula = {
+                        ...data.value,
+                        name: '@toddle/greaterThan',
+                        display_name: 'Greater than',
+                    };
+                    return set(data.files, data.path, newGreaterThanFormula);
+                }
+                case 'GTE': {
+                    const newGreaterOrEqualFormula = {
+                        ...data.value,
+                        name: '@toddle/greaterOrEqueal',
+                        display_name: 'Greater or equal',
+                    };
+                    return set(data.files, data.path, newGreaterOrEqualFormula);
+                }
+                case 'GROUP_BY': {
+                    const newGroupbyFormula = {
+                        ...data.value,
+                        name: '@toddle/groupBy',
+                        display_name: 'Group by',
+                        arguments: renameArguments(PREDICATE_ARGUMENT_MAPPINGS, data.value.arguments),
+                    };
+                    return set(data.files, data.path, newGroupbyFormula);
+                }
+                case 'IF': {
+                    const legacyIfFormula = omitKeys(data.value, ['arguments', 'name']);
+                    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+                    const ifArguments = data.value.arguments ?? [];
+                    const switchFormula = {
+                        ...legacyIfFormula,
+                        type: 'switch',
+                        cases: [
+                            {
+                                condition: ifArguments[0]?.formula,
+                                formula: ifArguments[1]?.formula,
+                            },
+                        ],
+                        default: ifArguments[2]?.formula,
+                    };
+                    return set(data.files, data.path, switchFormula);
+                }
+                case 'INDEX OF': {
+                    const newIndexofFormula = {
+                        ...data.value,
+                        name: '@toddle/indexOf',
+                        display_name: 'Index of',
+                        arguments: renameArguments(PREDICATE_ARGUMENT_MAPPINGS, data.value.arguments),
+                    };
+                    return set(data.files, data.path, newIndexofFormula);
+                }
+                case 'JSON_PARSE': {
+                    const newJsonParseFormula = {
+                        ...data.value,
+                        name: '@toddle/parseJSON',
+                        display_name: 'Parse JSON',
+                        arguments: renameArguments({ Input: 'JSON string' }, data.value.arguments),
+                    };
+                    return set(data.files, data.path, newJsonParseFormula);
+                }
+                case 'KEY_BY': {
+                    const newKeyByFormula = {
+                        ...data.value,
+                        name: '@toddle/keyBy',
+                        display_name: 'Key by',
+                        arguments: renameArguments({
+                            ...ARRAY_ARGUMENT_MAPPINGS,
+                            'Key formula': 'Formula',
+                        }, data.value.arguments),
+                    };
+                    return set(data.files, data.path, newKeyByFormula);
+                }
+                case 'LIST': {
+                    const newArrayFormula = {
+                        type: 'array',
+                        arguments: data.value.arguments,
+                    };
+                    return set(data.files, data.path, newArrayFormula);
+                }
+                case 'LOWER': {
+                    const newLowercaseFormula = {
+                        ...data.value,
+                        name: '@toddle/lowercase',
+                        display_name: 'Lower case',
+                    };
+                    return set(data.files, data.path, newLowercaseFormula);
+                }
+                case 'LT': {
+                    const newLessThanFormula = {
+                        ...data.value,
+                        name: '@toddle/lessThan',
+                        display_name: 'Less than',
+                    };
+                    return set(data.files, data.path, newLessThanFormula);
+                }
+                case 'LTE': {
+                    const newLessOrEqualFormula = {
+                        ...data.value,
+                        name: '@toddle/lessOrEqual',
+                        display_name: 'Less or equal',
+                    };
+                    return set(data.files, data.path, newLessOrEqualFormula);
+                }
+                case 'MOD': {
+                    const newModuloFormula = {
+                        ...data.value,
+                        arguments: renameArguments({ Dividor: 'Divider' }, data.value.arguments),
+                        name: '@toddle/modulo',
+                        display_name: 'Modulo',
+                    };
+                    return set(data.files, data.path, newModuloFormula);
+                }
+                case 'NEQ': {
+                    const newNotEqualFormula = {
+                        ...data.value,
+                        name: '@toddle/notEqual',
+                        display_name: 'Not equal',
+                    };
+                    return set(data.files, data.path, newNotEqualFormula);
+                }
+                case 'OR': {
+                    const { name, ...legacyOrFormula } = data.value;
+                    // Replace the AND formula with an 'and' formula
+                    const andFormula = {
+                        ...legacyOrFormula,
+                        type: 'or',
+                        arguments: legacyOrFormula.arguments.map((a) => {
+                            const { name, ...argument } = a;
+                            return argument;
+                        }),
+                    };
+                    return set(data.files, data.path, andFormula);
+                }
+                case 'RANDOM': {
+                    const newRandomNumberFormula = {
+                        ...data.value,
+                        name: '@toddle/randomNumber',
+                        display_name: 'Random number',
+                    };
+                    return set(data.files, data.path, newRandomNumberFormula);
+                }
+                case 'SIZE': {
+                    const newSizeFormula = {
+                        ...data.value,
+                        name: '@toddle/size',
+                        display_name: 'Size',
+                    };
+                    return set(data.files, data.path, newSizeFormula);
+                }
+                case 'SQRT': {
+                    const newSqrtFormula = {
+                        ...data.value,
+                        name: '@toddle/squareRoot',
+                        display_name: 'Square Root',
+                    };
+                    return set(data.files, data.path, newSqrtFormula);
+                }
+                case 'STARTS_WITH': {
+                    const newStartsWithFormula = {
+                        ...data.value,
+                        name: '@toddle/startsWith',
+                        display_name: 'Starts with',
+                        arguments: renameArguments({ Input: 'String' }, data.value.arguments),
+                    };
+                    return set(data.files, data.path, newStartsWithFormula);
+                }
+                case 'TAKE_LAST': {
+                    const newTakeLastFormula = {
+                        ...data.value,
+                        name: '@toddle/takeLast',
+                        display_name: 'Take last',
+                        arguments: renameArguments(ARRAY_ARGUMENT_MAPPINGS, data.value.arguments),
+                    };
+                    return set(data.files, data.path, newTakeLastFormula);
+                }
+                case 'TYPE':
+                    // We can't autofix this one as the types have changed
+                    break;
+                case 'UPPER': {
+                    const newUpperFormula = {
+                        ...data.value,
+                        name: '@toddle/uppercase',
+                        display_name: 'Uppercase',
+                        arguments: renameArguments(ARRAY_ARGUMENT_MAPPINGS, data.value.arguments),
+                    };
+                    return set(data.files, data.path, newUpperFormula);
+                }
+                case 'URI_ENCODE': {
+                    const newUriEncodeFormula = {
+                        ...data.value,
+                        name: '@toddle/encodeURIComponent',
+                        display_name: 'Encode URI Component',
+                        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+                        arguments: data.value.arguments?.map((arg) => ({
+                            ...arg,
+                            // Let's fix this typo as well
+                            name: arg.name === 'URI' ? 'URIComponent' : arg.name,
+                        })),
+                    };
+                    return set(data.files, data.path, newUriEncodeFormula);
+                }
+                // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! //
+                // ℹ️ Below is handling of the builtin formulas that can be updated ℹ️  //
+                // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! //
+                case 'ABSOLUTE': {
+                    const newAbsoluteFormula = {
+                        ...data.value,
+                        name: '@toddle/absolute',
+                        display_name: 'Absolute',
+                    };
+                    return set(data.files, data.path, newAbsoluteFormula);
+                }
+                case 'ADD': {
+                    const newAddFormula = {
+                        ...data.value,
+                        name: '@toddle/add',
+                        display_name: 'Add',
+                    };
+                    return set(data.files, data.path, newAddFormula);
+                }
+                case 'APPEND': {
+                    const newAppendFormula = {
+                        ...data.value,
+                        name: '@toddle/append',
+                        display_name: 'Append',
+                    };
+                    return set(data.files, data.path, newAppendFormula);
+                }
+                case 'BOOLEAN': {
+                    const newBooleanFormula = {
+                        ...data.value,
+                        name: '@toddle/boolean',
+                        display_name: 'Boolean',
+                    };
+                    return set(data.files, data.path, newBooleanFormula);
+                }
+                case 'CLAMP': {
+                    const newClampFormula = {
+                        ...data.value,
+                        name: '@toddle/clamp',
+                        display_name: 'Clamp',
+                    };
+                    return set(data.files, data.path, newClampFormula);
+                }
+                case 'DIVIDE': {
+                    const newDivideFormula = {
+                        ...data.value,
+                        name: '@toddle/divide',
+                        display_name: 'Divide',
+                    };
+                    return set(data.files, data.path, newDivideFormula);
+                }
+                case 'DROP': {
+                    const newDropFormula = {
+                        ...data.value,
+                        name: '@toddle/drop',
+                        display_name: 'Drop',
+                    };
+                    return set(data.files, data.path, newDropFormula);
+                }
+                case 'ENTRIES': {
+                    const newEntriesFormula = {
+                        ...data.value,
+                        name: '@toddle/entries',
+                        display_name: 'Entries',
+                    };
+                    return set(data.files, data.path, newEntriesFormula);
+                }
+                case 'EVERY': {
+                    const newEveryFormula = {
+                        ...data.value,
+                        name: '@toddle/every',
+                        display_name: 'Every',
+                        arguments: renameArguments(PREDICATE_ARGUMENT_MAPPINGS, data.value.arguments),
+                    };
+                    return set(data.files, data.path, newEveryFormula);
+                }
+                case 'FILTER': {
+                    const newFilterFormula = {
+                        ...data.value,
+                        name: '@toddle/filter',
+                        display_name: 'Filter',
+                        arguments: renameArguments(PREDICATE_ARGUMENT_MAPPINGS, data.value.arguments),
+                    };
+                    return set(data.files, data.path, newFilterFormula);
+                }
+                case 'FIND': {
+                    const newFindFormula = {
+                        ...data.value,
+                        name: '@toddle/find',
+                        display_name: 'Find',
+                        arguments: renameArguments(PREDICATE_ARGUMENT_MAPPINGS, data.value.arguments),
+                    };
+                    return set(data.files, data.path, newFindFormula);
+                }
+                case 'FROMENTRIES': {
+                    const newFromentriesFormula = {
+                        ...data.value,
+                        name: '@toddle/fromEntries',
+                        display_name: 'From entries',
+                        arguments: renameArguments(PREDICATE_ARGUMENT_MAPPINGS, data.value.arguments),
+                    };
+                    return set(data.files, data.path, newFromentriesFormula);
+                }
+                case 'GET': {
+                    const newGetFormula = {
+                        ...data.value,
+                        name: '@toddle/get',
+                        display_name: 'Get',
+                    };
+                    return set(data.files, data.path, newGetFormula);
+                }
+                case 'INCLUDES': {
+                    const newIncludesFormula = {
+                        ...data.value,
+                        name: '@toddle/includes',
+                        display_name: 'Includes',
+                        arguments: renameArguments(PREDICATE_ARGUMENT_MAPPINGS, data.value.arguments),
+                    };
+                    return set(data.files, data.path, newIncludesFormula);
+                }
+                case 'JOIN': {
+                    const newJoinFormula = {
+                        ...data.value,
+                        name: '@toddle/join',
+                        display_name: 'Join',
+                        arguments: renameArguments(PREDICATE_ARGUMENT_MAPPINGS, data.value.arguments),
+                    };
+                    return set(data.files, data.path, newJoinFormula);
+                }
+                case 'MAP': {
+                    const newMapFormula = {
+                        ...data.value,
+                        name: '@toddle/map',
+                        display_name: 'Map',
+                        arguments: renameArguments({
+                            ...ARRAY_ARGUMENT_MAPPINGS,
+                            'Mapping fx': 'Formula',
+                        }, data.value.arguments),
+                    };
+                    return set(data.files, data.path, newMapFormula);
+                }
+                case 'MAX': {
+                    const newMaxFormula = {
+                        ...data.value,
+                        name: '@toddle/max',
+                        display_name: 'Max',
+                        arguments: renameArguments(ARRAY_ARGUMENT_MAPPINGS, data.value.arguments),
+                    };
+                    return set(data.files, data.path, newMaxFormula);
+                }
+                case 'MIN': {
+                    const newMinFormula = {
+                        ...data.value,
+                        name: '@toddle/min',
+                        display_name: 'Min',
+                        arguments: renameArguments(ARRAY_ARGUMENT_MAPPINGS, data.value.arguments),
+                    };
+                    return set(data.files, data.path, newMinFormula);
+                }
+                case 'MINUS': {
+                    const newMinusFormula = {
+                        ...data.value,
+                        name: '@toddle/minus',
+                        display_name: 'Minus',
+                    };
+                    return set(data.files, data.path, newMinusFormula);
+                }
+                case 'MULTIPLY': {
+                    const newMultiplyFormula = {
+                        ...data.value,
+                        name: '@toddle/multiply',
+                        display_name: 'Multiply',
+                    };
+                    return set(data.files, data.path, newMultiplyFormula);
+                }
+                case 'NOT': {
+                    const newNotFormula = {
+                        ...data.value,
+                        name: '@toddle/not',
+                        display_name: 'Not',
+                    };
+                    return set(data.files, data.path, newNotFormula);
+                }
+                case 'NUMBER': {
+                    const newNumberFormula = {
+                        ...data.value,
+                        name: '@toddle/number',
+                        display_name: 'Number',
+                    };
+                    return set(data.files, data.path, newNumberFormula);
+                }
+                case 'RANGE': {
+                    const newRangeFormula = {
+                        ...data.value,
+                        name: '@toddle/range',
+                        display_name: 'Range',
+                        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+                        arguments: data.value.arguments?.map((arg, i) => ({
+                            ...arg,
+                            // The Max argument didn't always have a name
+                            name: i === 1 && typeof arg.name !== 'string' ? 'Max' : arg.name,
+                        })),
+                    };
+                    return set(data.files, data.path, newRangeFormula);
+                }
+                case 'REDUCE': {
+                    const newReduceFormula = {
+                        ...data.value,
+                        name: '@toddle/reduce',
+                        display_name: 'Reduce',
+                        arguments: renameArguments({ 'Reducer fx': 'Formula' }, data.value.arguments),
+                    };
+                    return set(data.files, data.path, newReduceFormula);
+                }
+                case 'REPLACEALL': {
+                    const newReplaceallFormula = {
+                        ...data.value,
+                        name: '@toddle/replaceAll',
+                        display_name: 'Replace all',
+                        arguments: renameArguments(
+                        // Yes, there was a typo in the old argument name
+                        { 'String to repalce': 'Search' }, data.value.arguments),
+                    };
+                    return set(data.files, data.path, newReplaceallFormula);
+                }
+                case 'REVERSE': {
+                    const newReverseFormula = {
+                        ...data.value,
+                        name: '@toddle/reverse',
+                        display_name: 'Reverse',
+                        arguments: renameArguments(ARRAY_ARGUMENT_MAPPINGS, data.value.arguments),
+                    };
+                    return set(data.files, data.path, newReverseFormula);
+                }
+                case 'ROUND': {
+                    const newRoundFormula = {
+                        ...data.value,
+                        name: '@toddle/round',
+                        display_name: 'Round',
+                    };
+                    return set(data.files, data.path, newRoundFormula);
+                }
+                case 'SET': {
+                    const newSetFormula = {
+                        ...data.value,
+                        name: '@toddle/set',
+                        display_name: 'Set',
+                    };
+                    return set(data.files, data.path, newSetFormula);
+                }
+                case 'SOME': {
+                    const newSomeFormula = {
+                        ...data.value,
+                        name: '@toddle/some',
+                        display_name: 'Some',
+                        arguments: renameArguments(PREDICATE_ARGUMENT_MAPPINGS, data.value.arguments),
+                    };
+                    return set(data.files, data.path, newSomeFormula);
+                }
+                case 'SPLIT': {
+                    const newSplitFormula = {
+                        ...data.value,
+                        name: '@toddle/split',
+                        display_name: 'Split',
+                    };
+                    return set(data.files, data.path, newSplitFormula);
+                }
+                case 'STRING': {
+                    const newStringFormula = {
+                        ...data.value,
+                        name: '@toddle/string',
+                        display_name: 'String',
+                    };
+                    return set(data.files, data.path, newStringFormula);
+                }
+                case 'SUM': {
+                    const newSumFormula = {
+                        ...data.value,
+                        name: '@toddle/sum',
+                        display_name: 'Sum',
+                    };
+                    return set(data.files, data.path, newSumFormula);
+                }
+                case 'TAKE': {
+                    const newTakeFormula = {
+                        ...data.value,
+                        name: '@toddle/take',
+                        display_name: 'Take',
+                        arguments: renameArguments(ARRAY_ARGUMENT_MAPPINGS, data.value.arguments),
+                    };
+                    return set(data.files, data.path, newTakeFormula);
+                }
+                case 'TRIM': {
+                    const newTrimFormula = {
+                        ...data.value,
+                        name: '@toddle/trim',
+                        display_name: 'Trim',
+                    };
+                    return set(data.files, data.path, newTrimFormula);
+                }
+            }
+        },
     },
 };
+const isIssue = (data) => data.nodeType === 'formula' &&
+    data.value.type === 'function' &&
+    isLegacyFormula(data.value, data.files);
 const isLegacyFormula = (formula, files) => {
     const pluginFormula = files.formulas?.[formula.name];
     if (isUpperCase(formula.name) &&
@@ -31,21 +619,34 @@ const isUpperCase = (str) => str === str.toUpperCase();
 const legacyFormulas = new Set([
     'and',
     'concat',
-    'count',
     'default',
     'delete',
+    'drop_last',
     'eq',
+    'find index',
     'flat',
     'gt',
     'gte',
+    'group_by',
     'if',
+    'index of',
+    'json_parse',
+    'key_by',
     'list',
+    'lower',
     'lt',
     'lte',
     'mod',
     'neq',
     'or',
+    'random',
+    'size',
+    'sqrt',
+    'starts_with',
+    'take_last',
     'type',
+    'upper',
+    'uri_encode',
 ]);
 // cSpell: disable
 const builtInFormulas = new Set([
@@ -139,4 +740,17 @@ const builtInFormulas = new Set([
     'uppercase',
 ]);
 // cSpell: enable
+const ARRAY_ARGUMENT_MAPPINGS = { List: 'Array' };
+const PREDICATE_ARGUMENT_MAPPINGS = {
+    ...ARRAY_ARGUMENT_MAPPINGS,
+    'Predicate fx': 'Formula',
+};
+const renameArguments = (mappings, args) => args?.map((arg) => ({
+    ...arg,
+    // Let's adjust the names
+    name: typeof arg.name === 'string'
+        ? // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+            (mappings[arg.name] ?? arg.name)
+        : arg.name,
+})) ?? [];
 //# sourceMappingURL=legacyFormulaRule.js.map