@appsemble/utils 0.20.41 → 0.20.43

package/remap.js

@@ -91,6 +91,13 @@ const mapperImplementations = {
         const values = mappers.map((mapper) => remap(mapper, input, context));
         return values.every((value) => equal(values[0], value));
     },
+    not(mappers, input, context) {
+        if (mappers.length <= 1) {
+            return false;
+        }
+        const [firstValue, ...otherValues] = mappers.map((mapper) => remap(mapper, input, context));
+        return !otherValues.some((value) => equal(firstValue, value));
+    },
     step(mapper, input, context) {
         return context.stepRef.current[mapper];
     },
@@ -149,6 +156,10 @@ const mapperImplementations = {
         const condition = remap(mappers.condition, input, context);
         return remap(condition ? mappers.then : mappers.else, input, context);
     },
+    match(mappers, input, context) {
+        var _a, _b;
+        return ((_b = remap((_a = mappers.find((mapper) => remap(mapper.case, input, context))) === null || _a === void 0 ? void 0 : _a.value, input, context)) !== null && _b !== void 0 ? _b : null);
+    },
     'object.from': (mappers, input, context) => mapValues(mappers, (mapper) => remap(mapper, input, context)),
     'object.assign': (mappers, input, context) => ({
         ...input,
@@ -295,6 +306,10 @@ const mapperImplementations = {
         }
         return input;
     },
+    log(level, input, context) {
+        console[level !== null && level !== void 0 ? level : 'info'](JSON.stringify({ input, context }, null, 2));
+        return input;
+    },
     'string.format'({ messageId, template, values }, input, context) {
         try {
             const message = context.getMessage({ id: messageId, defaultMessage: template });

package/remap.test.js

@@ -1,4 +1,4 @@
-import { IntlMessageFormat } from './intl-messageformat.js';
+import { IntlMessageFormat } from 'intl-messageformat';
 import { remap } from './remap.js';
 function runTests(tests) {
     it.each(Object.entries(tests))('should %s', (name, { context, expected, history, input, mappers, messages, userInfo }) => {
@@ -185,6 +185,68 @@ describe('date.format', () => {
         },
     });
 });
+describe('log', () => {
+    beforeEach(() => {
+        import.meta.jest.spyOn(console, 'error').mockImplementation();
+        import.meta.jest.spyOn(console, 'info').mockImplementation();
+        import.meta.jest.spyOn(console, 'warn').mockImplementation();
+    });
+    function runLogTests(tests) {
+        it.each(Object.entries(tests))('should %s', (name, { context, expected: expectedInput, history, input, mappers, messages, userInfo }) => {
+            const expected = JSON.stringify({
+                input: expectedInput,
+                context: {
+                    root: {
+                        message: 'hi mom!',
+                    },
+                    url: 'https://example.com/en/example',
+                    appUrl: 'https://example.com',
+                    appId: 6789,
+                    locale: 'en',
+                    pageData: {
+                        hello: 'Page data',
+                    },
+                },
+            }, null, 2);
+            remap(mappers, input, {
+                getMessage: ({ defaultMessage, id }) => { var _a, _b; return new IntlMessageFormat((_b = (_a = messages === null || messages === void 0 ? void 0 : messages.messageIds) === null || _a === void 0 ? void 0 : _a[id]) !== null && _b !== void 0 ? _b : defaultMessage); },
+                url: 'https://example.com/en/example',
+                appUrl: 'https://example.com',
+                userInfo,
+                context,
+                history,
+                appId: 6789,
+                locale: 'en',
+                pageData: { hello: 'Page data' },
+            });
+            expect(console[mappers.log]).toHaveBeenCalledWith(expected);
+        });
+    }
+    runLogTests({
+        'log `hi mom!` with log level `info`': {
+            input: { message: 'hi mom!' },
+            mappers: { log: 'info' },
+            expected: { message: 'hi mom!' },
+        },
+        'log `hi mom!` with log level `warn`': {
+            input: { message: 'hi mom!' },
+            mappers: { log: 'warn' },
+            expected: { message: 'hi mom!' },
+        },
+        'log `hi mom!` with log level `error`': {
+            input: { message: 'hi mom!' },
+            mappers: { log: 'error' },
+            expected: { message: 'hi mom!' },
+        },
+    });
+    runTests({
+        'return input': {
+            input: 'input',
+            mappers: { log: 'info' },
+            expected: 'input',
+        },
+    });
+});
 describe('le', () => {
     runTests({
         'return true if the left value is less than the right value': {
@@ -252,6 +314,35 @@ describe('equals', () => {
         },
     });
 });
+describe('not', () => {
+    runTests({
+        'return false if any of the values are equal to the first': {
+            input: [1, 2, 1],
+            mappers: { not: [{ prop: '0' }, { prop: '1' }, { prop: '2' }] },
+            expected: false,
+        },
+        'use deep equality': {
+            input: [{ foo: { bar: 3 } }, { foo: { bar: 3 } }],
+            mappers: { not: [{ prop: '0' }, { prop: '1' }] },
+            expected: false,
+        },
+        'return true if all values are not equal to the first': {
+            input: [{ foo: { bar: 3 } }, { foo: { bar: 2 } }, { foo: { bar: 2 } }],
+            mappers: { not: [{ prop: '0' }, { prop: '1' }] },
+            expected: true,
+        },
+        'return false on empty arrays': {
+            input: { empty: [] },
+            mappers: { not: [] },
+            expected: false,
+        },
+        'return false on arrays with 1 entry': {
+            input: { empty: [] },
+            mappers: { not: [{ prop: 'empty' }] },
+            expected: false,
+        },
+    });
+});
 describe('ics', () => {
     runTests({
         'support string date': {
@@ -463,6 +554,41 @@ describe('if', () => {
         },
     });
 });
+describe('match', () => {
+    runTests({
+        'return the value of the first case if case is truthy': {
+            input: {},
+            mappers: {
+                match: [
+                    { case: true, value: 'case 1' },
+                    { case: true, value: 'case 2' },
+                    { case: true, value: 'case 3' },
+                ],
+            },
+            expected: 'case 1',
+        },
+    });
+    runTests({
+        'return the value of the second case if case 1 is falsy and 2 is truthy': {
+            input: {},
+            mappers: {
+                match: [
+                    { case: false, value: 'case 1' },
+                    { case: true, value: 'case 2' },
+                    { case: false, value: 'case 3' },
+                ],
+            },
+            expected: 'case 2',
+        },
+    });
+    runTests({
+        'return null if all cases are falsy': {
+            input: {},
+            mappers: { match: [{ case: false, value: 'case 1' }] },
+            expected: null,
+        },
+    });
+});
 describe('object.from', () => {
     runTests({
         'create a new object from remappers': {

package/serverActions.d.ts

@@ -0,0 +1 @@
+export declare const serverActions: Set<string>;

package/serverActions.js

@@ -0,0 +1,13 @@
+export const serverActions = new Set([
+    'noop',
+    'throw',
+    'condition',
+    'each',
+    'email',
+    'log',
+    'notify',
+    'request',
+    'resource.query',
+    'static',
+]);
+//# sourceMappingURL=serverActions.js.map

package/theme.d.ts

@@ -1,4 +1,4 @@
-import { Theme } from '@appsemble/types';
+import { type Theme } from '@appsemble/types';
 /**
  * Merge multiple partial themes and the base theme into one resulting theme.
  *

package/validation.d.ts

@@ -1,7 +1,7 @@
-import { AppDefinition, BlockManifest } from '@appsemble/types';
-import { ValidatorResult } from 'jsonschema';
-import { Promisable } from 'type-fest';
-import { IdentifiableBlock } from './blockUtils.js';
+import { type AppDefinition, type BlockManifest } from '@appsemble/types';
+import { type ValidatorResult } from 'jsonschema';
+import { type Promisable } from 'type-fest';
+import { type IdentifiableBlock } from './blockUtils.js';
 /**
  * Check whether or not the given link represents a link related to the Appsemble core.
  *
@@ -18,7 +18,7 @@ export type BlockVersionsGetter = (blockMap: IdentifiableBlock[]) => Promisable<
  * @param definition The app validation to check.
  * @param getBlockVersions A function for getting block manifests from block versions.
  * @param validatorResult If specified, error messages will be applied to this existing validator
- * result.
+ *   result.
  * @returns A validator result which contains all app validation violations.
  */
 export declare function validateAppDefinition(definition: AppDefinition, getBlockVersions: BlockVersionsGetter, validatorResult?: ValidatorResult): Promise<ValidatorResult>;

package/validation.js

@@ -5,6 +5,7 @@ import { getAppBlocks, normalizeBlockName } from './blockUtils.js';
 import { has } from './has.js';
 import { partialNormalized } from './index.js';
 import { iterApp } from './iterApp.js';
+import { serverActions } from './serverActions.js';
 /**
  * Check whether or not the given link represents a link related to the Appsemble core.
  *
@@ -381,6 +382,10 @@ function validateActions(definition, report) {
     iterApp(definition, {
         onAction(action, path) {
             var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+            if (path[0] === 'cron' && !serverActions.has(action.type)) {
+                report(action.type, 'action type is not supported for cron jobs', [...path, 'type']);
+                return;
+            }
             if (action.type.startsWith('user.') && !definition.security) {
                 report(action.type, 'refers to a user action but the app doesn’t have a security definition', [...path, 'type']);
                 return;
@@ -587,7 +592,7 @@ function validateEvents(definition, blockVersions, report) {
  * @param definition The app validation to check.
  * @param getBlockVersions A function for getting block manifests from block versions.
  * @param validatorResult If specified, error messages will be applied to this existing validator
- * result.
+ *   result.
  * @returns A validator result which contains all app validation violations.
  */
 export async function validateAppDefinition(definition, getBlockVersions, validatorResult) {

package/intl-messageformat.d.ts

@@ -1,3 +0,0 @@
-import intl from 'intl-messageformat';
-export type IntlMessageFormat = intl;
-export declare const IntlMessageFormat: typeof intl;

package/intl-messageformat.js

@@ -1,5 +0,0 @@
-import intl from 'intl-messageformat';
-// @ts-expect-error Remove if the intl-message format types are fixed upstream
-// eslint-disable-next-line @typescript-eslint/no-redeclare
-export const IntlMessageFormat = (intl.IntlMessageFormat || intl);
-//# sourceMappingURL=intl-messageformat.js.map