@appsemble/utils 0.20.45 → 0.21.1

package/jsonschema.test.js

@@ -161,7 +161,7 @@ describe('combineSchemas', () => {
 });
 describe('iterJSONSchema', () => {
     it('should handle properties', () => {
-        const onSchema = import.meta.jest.fn();
+        const onSchema = vi.fn();
         const schema = {
             type: 'object',
             properties: {
@@ -174,7 +174,7 @@ describe('iterJSONSchema', () => {
         expect(onSchema).toHaveBeenCalledWith(schema.properties.foo);
     });
     it('should handle additionalProperties', () => {
-        const onSchema = import.meta.jest.fn();
+        const onSchema = vi.fn();
         const schema = {
             type: 'object',
             additionalProperties: { description: 'foo' },
@@ -185,7 +185,7 @@ describe('iterJSONSchema', () => {
         expect(onSchema).toHaveBeenCalledWith(schema.additionalProperties);
     });
     it('should handle an items object', () => {
-        const onSchema = import.meta.jest.fn();
+        const onSchema = vi.fn();
         const schema = {
             type: 'array',
             items: { description: 'foo' },
@@ -196,7 +196,7 @@ describe('iterJSONSchema', () => {
         expect(onSchema).toHaveBeenCalledWith(schema.items);
     });
     it('should handle an items array', () => {
-        const onSchema = import.meta.jest.fn();
+        const onSchema = vi.fn();
         const schema = {
             type: 'array',
             items: [{ description: 'foo' }, { description: 'bar' }],
@@ -208,7 +208,7 @@ describe('iterJSONSchema', () => {
         expect(onSchema).toHaveBeenCalledWith(schema.items[1]);
     });
     it('should handle additionalItems', () => {
-        const onSchema = import.meta.jest.fn();
+        const onSchema = vi.fn();
         const schema = {
             type: 'array',
             additionalItems: { description: 'foo' },
@@ -219,7 +219,7 @@ describe('iterJSONSchema', () => {
         expect(onSchema).toHaveBeenCalledWith(schema.additionalItems);
     });
     it('should handle anyOf', () => {
-        const onSchema = import.meta.jest.fn();
+        const onSchema = vi.fn();
         const schema = {
             type: 'array',
             anyOf: [{ description: 'foo' }],
@@ -230,7 +230,7 @@ describe('iterJSONSchema', () => {
         expect(onSchema).toHaveBeenCalledWith(schema.anyOf[0]);
     });
     it('should handle oneOf', () => {
-        const onSchema = import.meta.jest.fn();
+        const onSchema = vi.fn();
         const schema = {
             type: 'array',
             oneOf: [{ description: 'foo' }],
@@ -241,7 +241,7 @@ describe('iterJSONSchema', () => {
         expect(onSchema).toHaveBeenCalledWith(schema.oneOf[0]);
     });
     it('should handle allOf', () => {
-        const onSchema = import.meta.jest.fn();
+        const onSchema = vi.fn();
         const schema = {
             type: 'array',
             allOf: [{ description: 'foo' }],

package/normalize.js

@@ -14,11 +14,11 @@ export function normalize(input, stripTrailingHyphen = true) {
     const normalized = input
         // Normalize accents. https://stackoverflow.com/a/37511463/1154610
         .normalize('NFD')
-        .replace(/[\u0300-\u036F]/g, '')
+        .replaceAll(/[\u0300-\u036F]/g, '')
         // Make it lower case.
         .toLowerCase()
         // Replace any non-alphanumeric with single hyphens them at the start.
-        .replace(/[^\da-z]+/g, (match, index) => (index ? '-' : ''));
+        .replaceAll(/[^\da-z]+/g, (match, index) => (index ? '-' : ''));
     return stripTrailingHyphen ? normalized.replace(/-$/, '') : normalized;
 }
 //# sourceMappingURL=normalize.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@appsemble/utils",
-  "version": "0.20.45",
+  "version": "0.21.1",
   "description": "Utility functions used in Appsemble internally",
   "keywords": [
     "app",
@@ -28,10 +28,10 @@
   ],
   "scripts": {
     "prepack": "tsc --noEmit false",
-    "test": "NODE_OPTIONS=--experimental-vm-modules jest"
+    "test": "vitest"
   },
   "dependencies": {
-    "@appsemble/types": "0.20.45",
+    "@appsemble/types": "0.21.1",
     "axios": "^1.0.0",
     "cron-parser": "^4.0.0",
     "date-fns": "^2.0.0",
@@ -45,7 +45,7 @@
     "openapi-types": "^12.0.0",
     "parse-duration": "^1.0.0",
     "postcss": "^8.0.0",
-    "type-fest": "^3.0.0"
+    "type-fest": "^4.0.0"
   },
   "devDependencies": {
     "@types/langmap": "^0.0.1",

package/pem.js

@@ -1,8 +1,8 @@
 export function stripPem(pem, removeNewlines = false) {
     return pem
-        .replace(/^[\s-]*BEGIN [A-Z]+[\s-]*/g, '')
-        .replace(/[\s-]*END [A-Z]+[\s-]*$/g, '')
-        .replace(/\r?\n/g, removeNewlines ? '' : '\n')
+        .replaceAll(/^[\s-]*BEGIN [A-Z]+[\s-]*/g, '')
+        .replaceAll(/[\s-]*END [A-Z]+[\s-]*$/g, '')
+        .replaceAll(/\r?\n/g, removeNewlines ? '' : '\n')
         .trim();
 }
 export function wrapPem(pem, type) {

package/reference-schemas/remappers/arrays.d.ts

@@ -0,0 +1,2 @@
+import { type OpenAPIV3 } from 'openapi-types';
+export declare const arrayRemappers: Record<string, OpenAPIV3.ReferenceObject | OpenAPIV3.SchemaObject>;

package/reference-schemas/remappers/arrays.js

@@ -0,0 +1,334 @@
+export const arrayRemappers = {
+    'array.map': {
+        $ref: '#/components/schemas/RemapperDefinition',
+        description: `
+The remapper goes through the given array and applies the given remappers on each individual item.
+This can be very handy when sorting arrays by certain data. The remapper always returns an array.
+Output can be an empty array if the supplied data isn’t an array.
+
+For example, if you want to sort through a list of people and only get their occupations you can do
+the following:
+
+Input:
+
+\`\`\`json
+[
+  {
+    "name": "Peter",
+    "occupation": "Delivery driver"
+  },
+  {
+    "name": "Otto",
+    "occupation": "Scientist"
+  },
+  {
+    "name": "Harry",
+    "occupation": "CEO"
+  }
+]
+\`\`\`
+
+\`\`\`yaml
+array.map:
+  object.omit:
+    - name
+\`\`\`
+
+Result:
+
+\`\`\`json
+[{ "occupation": "Delivery driver" }, { "occupation": "Scientist" }, { "occupation": "CEO" }]
+\`\`\`
+
+Another great use for \`array.map\` is to combine it with the \`if\` remapper and sort your arrays on
+specific values.
+
+Using the same input data from the previous example, look at how you can change the code to get
+people from a specific occupation:
+
+\`\`\`yaml
+- array.map:
+    if:
+      condition: { equals: [{ prop: occupation }, Scientist] }
+      then:
+        object.from:
+          name:
+            prop: name
+          occupation:
+            prop: occupation
+      else: null
+- null.strip: null
+\`\`\`
+
+Result:
+
+\`\`\`json
+[
+  {
+    "name": "Otto",
+    "occupation": "Scientist"
+  }
+]
+\`\`\`
+
+Because \`array.map\` returns an array, every item has to return something. This is why we have to
+return the full object with the data we want in the \`then\` section. It’s also why we return \`null\`.
+This results in an array consisting of \`null\` values and objects with actual data in them. To solve
+this problem, we use the \`null.strip\` remapper to remove any null values which results in a clean
+array.
+`,
+    },
+    'array.unique': {
+        $ref: '#/components/schemas/RemapperDefinition',
+        description: `
+Filters out unique values from an array. The value Remapper is applied to each entry in the array
+using its result to determine uniqueness.
+
+If the value Remapper results in undefined or null, the entire entry is used for uniqueness.
+
+If the input is not an array, the input is returned without any modifications.
+
+Input:
+
+\`\`\`json
+[1, 1, 2, 3]
+\`\`\`
+
+\`\`\`yaml
+array.unique: null
+\`\`\`
+
+Result:
+
+\`\`\`json
+[1, 2, 3]
+\`\`\`
+
+You can also check for more complex values in arrays. The remapper accepts remappers as well, so you
+can also use entire objects to check for unique values.
+
+For this example, we have the following extended data with some duplicate values:
+
+\`\`\`json
+[
+  {
+    "name": "Peter",
+    "occupation": "Delivery driver",
+    "age": 19
+  },
+  {
+    "name": "Peter",
+    "occupation": "Photographer",
+    "age": 19
+  },
+  {
+    "name": "Otto",
+    "occupation": "Scientist",
+    "age": 50
+  },
+  {
+    "name": "Harry",
+    "occupation": "CEO",
+    "age": 20
+  }
+]
+\`\`\`
+
+We can be fairly sure in this list of people the first two Peters are the same person but with a
+different occupation. To get more complex unique values from here, we can do the following:
+
+\`\`\`yaml
+array.unique:
+  object.from:
+    name: { prop: name }
+    age: { prop: age }
+\`\`\`
+
+This then checks the array for unique values in both the \`name\` and \`age\` fields. The result of this
+remapper is a filtered list:
+
+\`\`\`json
+[
+  {
+    "name": "Peter",
+    "occupation": "Delivery driver",
+    "age": 19
+  },
+  {
+    "name": "Otto",
+    "occupation": "Scientist",
+    "age": 50
+  },
+  {
+    "name": "Harry",
+    "occupation": "CEO",
+    "age": 20
+  }
+]
+\`\`\`
+    `,
+    },
+    'array.from': {
+        type: 'array',
+        items: {
+            $ref: '#/components/schemas/RemapperDefinition',
+        },
+        description: `
+Creates a new array based on a provided array of remappers. This array can also consist of static
+values.
+
+For example:
+
+\`\`\`yaml
+array.from:
+  - Peter
+  - Otto
+  - Harry
+\`\`\`
+
+\`\`\`json
+["Peter", "Otto", "Harry"]
+\`\`\`
+
+This remapper can also be used to convert given data into an array.
+
+Input:
+
+\`\`\`json
+{
+  "name": "Peter",
+  "occupation": "Delivery driver"
+}
+\`\`\`
+
+\`\`\`yaml
+array.from:
+  - root: null # Takes the data passed to this remapper, explained more in the 'Data' page
+\`\`\`
+
+Result:
+
+\`\`\`json
+[
+  {
+    "name": "Peter",
+    "occupation": "Delivery driver"
+  }
+]
+\`\`\`
+    `,
+    },
+    'array.append': {
+        type: 'array',
+        items: {
+            $ref: '#/components/schemas/RemapperDefinition',
+        },
+        description: `
+Append new values to the end of an array. If the input is not an array an empty array is returned.
+
+Using the array from the previous example, we can add a new object on top of it using this remapper:
+
+\`\`\`yaml
+array.append:
+  - object.from:
+      name: James
+      occupation: News reporter
+\`\`\`
+
+Result:
+
+\`\`\`json
+[
+  {
+    "name": "Peter",
+    "occupation": "Delivery driver"
+  },
+  {
+    "name": "Otto",
+    "occupation": "Scientist"
+  },
+  {
+    "name": "Harry",
+    "occupation": "CEO"
+  },
+  {
+    "name": "James",
+    "occupation": "News reporter"
+  }
+]
+\`\`\`
+    `,
+    },
+    'array.omit': {
+        type: 'array',
+        items: {
+            $ref: '#/components/schemas/RemapperDefinition',
+        },
+        description: `
+Remove values from an array. The input is expected to be the index(es) of the items to be deleted.
+Accepts an array of static or remapper values.
+
+With the previous example we added a new person to the list of people, so now we can remove that
+person. We already know the index of this person in the array is \`3\`, so it’s easy:
+
+\`\`\`yaml
+array.omit:
+  - 3
+\`\`\`
+
+Result:
+
+\`\`\`json
+[
+  {
+    "name": "Peter",
+    "occupation": "Delivery driver"
+  },
+  {
+    "name": "Otto",
+    "occupation": "Scientist"
+  },
+  {
+    "name": "Harry",
+    "occupation": "CEO"
+  }
+]
+\`\`\`
+
+However, usually we don’t know the exact index of the item we want to delete. Because the remapper
+accepts remappers as input we can get the desired item’s ID from another source as well. Take the
+following example:
+
+In this example we assume the data from the previous example is passed to this table block using a
+data loader’s emitting event called “people”. When the user clicks on one of the people in the
+table, it gets the list of people again. Using the index of this person, and the \`array.omit\`
+remapper, the person gets removed from the list.
+
+\`\`\`yaml
+type: table
+version: 0.20.38
+events:
+  listen:
+    data: people
+parameters:
+  fields:
+    - label: Name
+      value: { prop: name }
+      onClick: removePerson
+    - label: Occupation
+      value: { prop: occupation }
+actions:
+  removePerson:
+    type: resource.query
+    resource: citizensNYC
+    remapAfter:
+      array.omit:
+        - context: index # This gets the index of the item in the table, explained more in the 'Data' page.
+    onSuccess:
+      type: resource.update
+      resource: citizensNYC
+\`\`\`
+    `,
+    },
+};
+//# sourceMappingURL=arrays.js.map

package/reference-schemas/remappers/conditionals.d.ts

@@ -0,0 +1,2 @@
+import { type OpenAPIV3 } from 'openapi-types';
+export declare const conditionalRemappers: Record<string, OpenAPIV3.ReferenceObject | OpenAPIV3.SchemaObject>;

package/reference-schemas/remappers/conditionals.js

@@ -0,0 +1,93 @@
+export const conditionalRemappers = {
+    if: {
+        type: 'object',
+        description: `Check if condition results in a truthy value.
+
+Returns value of then if condition is truthy, otherwise it returns the value of else.
+`,
+        additionalProperties: false,
+        required: ['condition', 'then', 'else'],
+        properties: {
+            condition: {
+                $ref: '#/components/schemas/RemapperDefinition',
+                description: 'The condition to check.',
+            },
+            then: {
+                $ref: '#/components/schemas/RemapperDefinition',
+                description: 'This remapper is used if the condition returns true.',
+            },
+            else: {
+                $ref: '#/components/schemas/RemapperDefinition',
+                description: 'This remapper is used if the condition returns false.',
+            },
+        },
+    },
+    equals: {
+        type: 'array',
+        items: {
+            $ref: '#/components/schemas/RemapperDefinition',
+        },
+        description: `Compare all computed remapper values against each other.
+
+Returns \`true\` if all entries are equal, otherwise \`false\`.
+`,
+    },
+    gt: {
+        type: 'array',
+        description: `Compare the first computed remapper value with the second computed remapper value.
+
+Returns \`true\` if the first entry is greater than the second entry.`,
+        minItems: 2,
+        maxItems: 2,
+        items: {
+            $ref: '#/components/schemas/RemapperDefinition',
+        },
+    },
+    lt: {
+        type: 'array',
+        description: `Compare the first computed remapper value with the second computed remapper value.
+
+Returns \`true\` if the first entry is lesser than the second entry.`,
+        minItems: 2,
+        maxItems: 2,
+        items: {
+            $ref: '#/components/schemas/RemapperDefinition',
+        },
+    },
+    not: {
+        type: 'array',
+        items: {
+            $ref: '#/components/schemas/RemapperDefinition',
+        },
+        description: `Compare all computed remapper values against the first.
+
+Returns \`false\` if all entries are equal to the first entry, otherwise \`true\`.
+
+If only one remapper or none is passed, the remapper value gets computed and then inverted.
+`,
+    },
+    match: {
+        type: 'array',
+        description: `Check if any case results in a truthy value.
+
+Returns the value of the first case where the condition equals true, otherwise returns null.
+`,
+        items: {
+            type: 'object',
+            additionalProperties: false,
+            required: ['case', 'value'],
+            description: '',
+            properties: {
+                case: {
+                    $ref: '#/components/schemas/RemapperDefinition',
+                    description: 'The condition to check.',
+                },
+                value: {
+                    $ref: '#/components/schemas/RemapperDefinition',
+                    description: 'This remapper is used if the case is true',
+                },
+            },
+        },
+    },
+};
+//# sourceMappingURL=conditionals.js.map

package/reference-schemas/remappers/data.d.ts

@@ -0,0 +1,2 @@
+import { type OpenAPIV3 } from 'openapi-types';
+export declare const dataRemappers: Record<string, OpenAPIV3.ReferenceObject | OpenAPIV3.SchemaObject>;