@appsemble/utils 0.30.14-test.6 → 0.32.1-test.14

package/remap.js

@@ -1,5 +1,7 @@
+import { filter, literalValues, param } from '@odata/parser';
 import { addMilliseconds, format, parse, parseISO } from 'date-fns';
 import equal from 'fast-deep-equal';
+import { XMLParser } from 'fast-xml-parser';
 import { createEvent } from 'ics';
 import parseDuration from 'parse-duration';
 import { has } from './has.js';
@@ -13,6 +15,15 @@ class RemapperError extends TypeError {
         this.remapper = remapper;
     }
 }
+function isPlainObject(value) {
+    return value != null && typeof value === 'object' && !Array.isArray(value);
+}
+function isEqualArray(a, b) {
+    if (a.length !== b.length) {
+        return false;
+    }
+    return a.every((val, i) => val === b[i]);
+}
 export function remap(remapper, input, context) {
     if (typeof remapper === 'string' ||
         typeof remapper === 'number' ||
@@ -104,14 +115,32 @@ const mapperImplementations = {
         const [firstValue, ...otherValues] = mappers.map((mapper) => remap(mapper, input, context));
         return !otherValues.some((value) => equal(firstValue, value));
     },
+    or(mappers, input, context) {
+        const values = mappers.map((mapper) => Boolean(remap(mapper, input, context)));
+        return values.length > 0 ? values.includes(true) : true;
+    },
+    and(mappers, input, context) {
+        const values = mappers.map((mapper) => remap(mapper, input, context));
+        return values.every(Boolean);
+    },
     step(mapper, input, context) {
+        // eslint-disable-next-line @typescript-eslint/prefer-ts-expect-error
+        // @ts-ignore 18048 variable is possibly undefined (strictNullChecks)
         return context.stepRef.current[mapper];
     },
     'tab.name'(mapper, input, context) {
+        // eslint-disable-next-line @typescript-eslint/prefer-ts-expect-error
+        // @ts-ignore 18048 variable is possibly undefined (strictNullChecks)
         return context.tabRef.current.name;
     },
-    gt: ([left, right], input, context) => remap(left, input, context) > remap(right, input, context),
-    lt: ([left, right], input, context) => remap(left, input, context) < remap(right, input, context),
+    gt: ([left, right], input, context) => 
+    // eslint-disable-next-line @typescript-eslint/prefer-ts-expect-error
+    // @ts-ignore Messed up - 2571 Object is of type 'unknown'.
+    remap(left, input, context) > remap(right, input, context),
+    lt: ([left, right], input, context) => 
+    // eslint-disable-next-line @typescript-eslint/prefer-ts-expect-error
+    // @ts-ignore Messed up - 2571 Object is of type 'unknown'.
+    remap(left, input, context) < remap(right, input, context),
     ics(mappers, input, context) {
         let event;
         const mappedStart = remap(mappers.start, input, context);
@@ -127,10 +156,10 @@ const mapperImplementations = {
             startInputType: 'utc',
             startOutputType: 'utc',
             title: remap(mappers.title, input, context),
-            description: remap(mappers.description, input, context),
-            url: remap(mappers.url, input, context),
-            location: remap(mappers.location, input, context),
-            geo: processLocation(remap(mappers.coordinates, input, context)),
+            description: remap(mappers.description ?? null, input, context),
+            url: remap(mappers.url ?? null, input, context),
+            location: remap(mappers.location ?? null, input, context),
+            geo: processLocation(remap(mappers.coordinates ?? null, input, context)),
             productId: context.appUrl,
         };
         if ('end' in mappers) {
@@ -166,14 +195,15 @@ const mapperImplementations = {
         return remap(condition ? mappers.then : mappers.else, input, context);
     },
     match(mappers, input, context) {
-        return (remap(mappers.find((mapper) => remap(mapper.case, input, context))?.value, input, context) ??
-            null);
+        return (remap(mappers.find((mapper) => remap(mapper.case, input, context))?.value ?? null, input, context) ?? null);
     },
     'object.from': (mappers, input, context) => mapValues(mappers, (mapper) => remap(mapper, input, context)),
     'object.assign': (mappers, input, context) => ({
         ...input,
         ...mapValues(mappers, (mapper) => remap(mapper, input, context)),
     }),
+    // eslint-disable-next-line @typescript-eslint/prefer-ts-expect-error
+    // @ts-ignore 2322 ... is not assignable to type (strictNullChecks)
     'object.omit'(keys, input) {
         const result = { ...input };
         for (const key of keys) {
@@ -194,6 +224,54 @@ const mapperImplementations = {
         }
         return result;
     },
+    'object.compare'([remapper1, remapper2], input, context) {
+        const remapped1 = remap(remapper1, input, context);
+        const remapped2 = remap(remapper2, input, context);
+        function deepDiff(obj1, obj2, path = []) {
+            const diffs = [];
+            const keys = new Set([...Object.keys(obj1 || {}), ...Object.keys(obj2 || {})]);
+            for (const key of keys) {
+                const val1 = obj1?.[key];
+                const val2 = obj2?.[key];
+                const currentPath = [...path, key];
+                if (isPlainObject(val1) && isPlainObject(val2)) {
+                    diffs.push(...deepDiff(val1, val2, currentPath));
+                }
+                else if (Array.isArray(val1) && Array.isArray(val2)) {
+                    if (!isEqualArray(val1, val2)) {
+                        diffs.push({ path: currentPath, type: 'changed', from: val1, to: val2 });
+                    }
+                }
+                else if (!(key in obj1)) {
+                    diffs.push({ path: currentPath, type: 'added', value: val2 });
+                }
+                else if (!(key in obj2)) {
+                    diffs.push({ path: currentPath, type: 'removed', value: val1 });
+                }
+                else if (val1 !== val2) {
+                    diffs.push({ path: currentPath, type: 'changed', from: val1, to: val2 });
+                }
+            }
+            return diffs;
+        }
+        if (!isPlainObject(remapped1) || !isPlainObject(remapped2)) {
+            return [];
+        }
+        return deepDiff(remapped1, remapped2);
+    },
+    'object.explode'(property, input) {
+        if (!isPlainObject(input)) {
+            return [];
+        }
+        const { [property]: arrayValue, ...rest } = input;
+        if (!Array.isArray(arrayValue)) {
+            return [];
+        }
+        return arrayValue.map((item) => ({
+            ...rest,
+            ...item,
+        }));
+    },
     type(args, input) {
         // eslint-disable-next-line eqeqeq
         if (input === null) {
@@ -204,9 +282,17 @@ const mapperImplementations = {
         }
         return typeof input;
     },
+    // eslint-disable-next-line @typescript-eslint/prefer-ts-expect-error
+    // @ts-ignore 2322 ... is not assignable to type (strictNullChecks)
     'array.map': (mapper, input, context) => input?.map((item, index) => remap(mapper, item, {
         ...context,
-        array: { index, length: input.length, item },
+        array: {
+            index,
+            length: input.length,
+            item,
+            prevItem: input[index - 1],
+            nextItem: input[index + 1],
+        },
     })) ?? [],
     'array.unique'(mapper, input, context) {
         if (!Array.isArray(input)) {
@@ -216,7 +302,13 @@ const mapperImplementations = {
             ? item
             : remap(mapper, item, {
                 ...context,
-                array: { index, length: input.length, item },
+                array: {
+                    index,
+                    length: input.length,
+                    item,
+                    prevItem: input[index - 1],
+                    nextItem: input[index + 1],
+                },
             }));
         return input.filter((value, index) => {
             for (let i = 0; i < index; i += 1) {
@@ -227,7 +319,11 @@ const mapperImplementations = {
             return true;
         });
     },
+    // eslint-disable-next-line @typescript-eslint/prefer-ts-expect-error
+    // @ts-ignore 2322 ... is not assignable to type (strictNullChecks)
     array: (prop, input, context) => context.array?.[prop],
+    // eslint-disable-next-line @typescript-eslint/prefer-ts-expect-error
+    // @ts-ignore 2322 ... is not assignable to type (strictNullChecks)
     'array.filter'(mapper, input, context) {
         if (!Array.isArray(input)) {
             console.error(`${input} is not an array!`);
@@ -236,11 +332,19 @@ const mapperImplementations = {
         return input?.filter((item, index) => {
             const remapped = remap(mapper, item, {
                 ...context,
-                array: { index, length: input.length, item },
+                array: {
+                    index,
+                    length: input.length,
+                    item,
+                    prevItem: input[index - 1],
+                    nextItem: input[index + 1],
+                },
             });
             return remapped;
         });
     },
+    // eslint-disable-next-line @typescript-eslint/prefer-ts-expect-error
+    // @ts-ignore 2322 ... is not assignable to type (strictNullChecks)
     'array.find'(mapper, input, context) {
         if (!Array.isArray(input)) {
             console.error(`${input} is not an array!`);
@@ -337,6 +441,8 @@ const mapperImplementations = {
         }
         return remapped;
     },
+    // eslint-disable-next-line @typescript-eslint/prefer-ts-expect-error
+    // @ts-ignore 2322 ... is not assignable to type (strictNullChecks)
     'date.parse': (fmt, input) => (fmt ? parse(input, fmt, new Date()) : parseISO(input)),
     'date.now': () => new Date(),
     'date.add'(time, input) {
@@ -355,6 +461,8 @@ const mapperImplementations = {
         return args ? format(date, args) : date.toJSON();
     },
     'null.strip': (args, input) => stripNullValues(input, args || {}),
+    // eslint-disable-next-line @typescript-eslint/prefer-ts-expect-error
+    // @ts-ignore 2322 ... is not assignable to type (strictNullChecks)
     'random.choice': (args, input) => Array.isArray(input) ? input[Math.floor(Math.random() * input.length)] : input,
     'random.integer'(args) {
         const min = Math.min(...args);
@@ -375,14 +483,19 @@ const mapperImplementations = {
         return result.join('');
     },
     root: (args, input, context) => context.root,
+    // eslint-disable-next-line @typescript-eslint/prefer-ts-expect-error
+    // @ts-ignore 2322 ... is not assignable to type (strictNullChecks)
+    len: (args, input) => input?.length,
     history: (index, input, context) => context.history?.[index],
-    'from.history': ({ index, props }, input, context) => mapValues(props, (mapper) => remap(mapper, context.history[index], context)),
+    'from.history': ({ index, props }, input, context) => mapValues(props, (mapper) => remap(mapper, context.history?.[index], context)),
     'assign.history': ({ index, props }, input, context) => ({
         ...input,
-        ...mapValues(props, (mapper) => remap(mapper, context.history[index], context)),
+        ...mapValues(props, (mapper) => remap(mapper, context.history?.[index], context)),
     }),
+    // eslint-disable-next-line @typescript-eslint/prefer-ts-expect-error
+    // @ts-ignore 2322 ... is not assignable to type (strictNullChecks)
     'omit.history'({ index, keys }, input, context) {
-        const result = { ...context.history[index] };
+        const result = { ...context.history?.[index] };
         for (const key of keys) {
             if (Array.isArray(key)) {
                 let acc = result;
@@ -410,13 +523,45 @@ const mapperImplementations = {
         }
         return input;
     },
+    // eslint-disable-next-line @typescript-eslint/prefer-ts-expect-error
+    // @ts-ignore 2322 ... is not assignable to type (strictNullChecks)
+    'string.startsWith'(substring, input) {
+        if (typeof substring === 'string') {
+            return input.startsWith(substring);
+        }
+        if (substring.strict || substring.strict === undefined) {
+            return input.startsWith(substring.substring);
+        }
+        return input.toLowerCase().startsWith(substring.substring.toLowerCase());
+    },
+    // eslint-disable-next-line @typescript-eslint/prefer-ts-expect-error
+    // @ts-ignore 2322 ... is not assignable to type (strictNullChecks)
+    'string.endsWith'(substring, input) {
+        if (typeof substring === 'string') {
+            return input.endsWith(substring);
+        }
+        if (substring.strict || substring.strict === undefined) {
+            return input.endsWith(substring.substring);
+        }
+        return input.toLowerCase().endsWith(substring.substring.toLowerCase());
+    },
+    // eslint-disable-next-line @typescript-eslint/prefer-ts-expect-error
+    // @ts-ignore 2322 null is not assignable to type (strictNullChecks)
+    slice(sliceIndex, input) {
+        try {
+            return Array.isArray(sliceIndex) ? input.slice(...sliceIndex) : input.slice(sliceIndex);
+        }
+        catch {
+            return null;
+        }
+    },
     log(level, input, context) {
         console[level ?? 'info'](JSON.stringify({ input, context }, null, 2));
         return input;
     },
     'string.format'({ messageId, template, values }, input, context) {
         try {
-            const remappedMessageId = remap(messageId, input, context);
+            const remappedMessageId = remap(messageId ?? null, input, context);
             const message = context.getMessage({ id: remappedMessageId, defaultMessage: template });
             return message.format(values ? mapValues(values, (val) => remap(val, input, context)) : undefined);
         }
@@ -448,5 +593,37 @@ const mapperImplementations = {
         const url = `http://${containerName}.${namespace}.svc.cluster.local/${endpoint}`;
         return url;
     },
+    'filter.from'(values, input, context) {
+        let result = filter();
+        for (const [field, { comparator, type, value }] of Object.entries(values)) {
+            const remapped = remap(value, input, context);
+            const remappedDefined = remapped === undefined ? null : remapped;
+            const literal = type === 'String' && value != null
+                ? literalValues[type](remappedDefined.replaceAll("'", "''").replaceAll('\\', '\\\\'))
+                : literalValues[type === 'Number' ? 'Decimal' : type](remappedDefined);
+            result = result.field(field)[comparator](literal);
+        }
+        return String(param().filter(result)).replace(/^\$filter=/, '');
+    },
+    'order.from'(values) {
+        return String(param().orderby(Object.entries(values).map(([key, order]) => ({ field: key, order })))).replace('$orderby=', '');
+    },
+    'xml.parse'(value, input, context) {
+        const parser = new XMLParser({
+            ignoreAttributes: false,
+            attributeNamePrefix: '',
+        });
+        try {
+            return parser.parse(remap(value, input, context) || '');
+        }
+        catch (error) {
+            console.error(error);
+            return {};
+        }
+    },
+    defined(value, input, context) {
+        const remapped = remap(value, input, context);
+        return remapped !== undefined && remapped != null;
+    },
 };
 //# sourceMappingURL=remap.js.map

package/serializeResource.d.ts

@@ -1,2 +1,9 @@
 import { type JsonValue } from 'type-fest';
+/**
+ * Works on a resource on the client, for example passed from the form block
+ *
+ * @param data The resource to be serialized, optionally containing asset blobs
+ * @returns A FormData instance containing the resource and an array of the assets
+ *   referenced from the resource
+ */
 export declare function serializeResource(data: any): FormData | JsonValue;

package/serializeResource.js

@@ -1,4 +1,11 @@
 import { mapValues } from './mapValues.js';
+/**
+ * Works on a resource on the client, for example passed from the form block
+ *
+ * @param data The resource to be serialized, optionally containing asset blobs
+ * @returns A FormData instance containing the resource and an array of the assets
+ *   referenced from the resource
+ */
 export function serializeResource(data) {
     const assets = [];
     const extractAssets = (value) => {

package/serverActions.d.ts

@@ -1,2 +1,2 @@
-export declare const serverActions: Set<"log" | "condition" | "each" | "email" | "noop" | "notify" | "static" | "throw" | "request" | "resource.create" | "resource.delete" | "resource.get" | "resource.patch" | "resource.query" | "resource.update">;
+export declare const serverActions: Set<"log" | "condition" | "each" | "email" | "noop" | "notify" | "static" | "throw" | "request" | "resource.create" | "resource.delete" | "resource.delete.all" | "resource.delete.bulk" | "resource.get" | "resource.patch" | "resource.query" | "resource.update">;
 export type ServerActionName = typeof serverActions extends Set<infer T> ? T : never;

package/serverActions.js

@@ -13,6 +13,8 @@ export const serverActions = new Set([
     'resource.patch',
     'resource.update',
     'resource.delete',
+    'resource.delete.all',
+    'resource.delete.bulk',
     'static',
 ]);
 //# sourceMappingURL=serverActions.js.map

package/theme.js

@@ -19,7 +19,11 @@ export function mergeThemes(...themes) {
  */
 export function createThemeURL(theme) {
     const { font, ...rest } = theme;
-    const params = new URLSearchParams({ ...rest, fontFamily: font.family, fontSource: font.source });
+    const params = new URLSearchParams({
+        ...rest,
+        fontFamily: font.family,
+        fontSource: font.source ?? '',
+    });
     // Sort for cacheability.
     params.sort();
     return `/bulma/0.9.3/bulma.min.css?${params}`;

package/validateStyle.js

@@ -7,6 +7,8 @@ export class StyleValidationError extends Error {
 }
 export function validateStyle(css) {
     if (!css) {
+        // eslint-disable-next-line @typescript-eslint/prefer-ts-expect-error
+        // @ts-ignore 2322 null is not assignable to type (strictNullChecks)
         return null;
     }
     try {

package/validation.js

@@ -32,7 +32,7 @@ function validateJSONSchema(schema, prefix, report) {
                     }
                 }
             }
-            for (const [key, propertySchema] of Object.entries(schema.properties)) {
+            for (const [key, propertySchema] of Object.entries(schema.properties ?? {})) {
                 validateJSONSchema(propertySchema, [...prefix, 'properties', key], report);
             }
         }
@@ -87,7 +87,7 @@ function validateMembersSchema(definition, report) {
         if (!('type' in schema) && !('enum' in schema)) {
             report(schema, 'must define type or enum', prefix);
         }
-        if ('reference' in propertyDefinition) {
+        if ('reference' in propertyDefinition && propertyDefinition.reference) {
             const { resource: resourceName } = propertyDefinition.reference;
             const resourceDefinition = definition.resources?.[resourceName];
             if (!resourceDefinition) {
@@ -134,7 +134,7 @@ function validateResourceSchemas(definition, report) {
             report(schema.type, 'must define type object', [...prefix, 'type']);
         }
         if ('properties' in schema) {
-            for (const [propertyName, propertySchema] of Object.entries(schema.properties)) {
+            for (const [propertyName, propertySchema] of Object.entries(schema.properties ?? {})) {
                 if (propertyName === 'id') {
                     for (const [validatorKey, value] of Object.entries(propertySchema)) {
                         if (validatorKey === 'description' || validatorKey === 'title') {
@@ -365,7 +365,7 @@ function validatePermissions(appDefinition, permissions, inheritedPermissions, p
             if (resourceViewPermissionPattern.test(permission)) {
                 const [, resourceName, , resourceView] = permission.split(':');
                 if (resourceName === 'all') {
-                    for (const [rName, resourceDefinition] of Object.entries(appDefinition.resources)) {
+                    for (const [rName, resourceDefinition] of Object.entries(appDefinition.resources ?? {})) {
                         if (!resourceDefinition.views?.[resourceView]) {
                             report(appDefinition, `resource ${rName} is missing a definition for the ${resourceView} view`, [...path, 'permissions', index]);
                             return;
@@ -373,7 +373,7 @@ function validatePermissions(appDefinition, permissions, inheritedPermissions, p
                     }
                 }
                 else {
-                    if (!appDefinition.resources[resourceName]?.views?.[resourceView]) {
+                    if (!appDefinition.resources?.[resourceName]?.views?.[resourceView]) {
                         report(appDefinition, `resource ${resourceName} is missing a definition for the ${resourceView} view`, [...path, 'permissions', index]);
                         return;
                     }
@@ -617,7 +617,7 @@ function checkCyclicRoleInheritance(roles, name, report) {
             return true;
         }
         stack.push(role);
-        return roles[role]?.inherits?.some(checkRoleRecursively);
+        return Boolean(roles[role]?.inherits?.some(checkRoleRecursively));
     };
     const duplicate = checkRoleRecursively(name);
     if (duplicate && lastChecked === name) {
@@ -634,7 +634,7 @@ function validateSecurity(definition, report) {
     const { notifications, security } = definition;
     const predefinedRoles = Object.keys(PredefinedAppRole);
     const checkRoleExists = (name, path, roles = predefinedRoles) => {
-        if (!has(security.roles, name) && !roles.includes(name)) {
+        if (!has(security?.roles, name) && !roles.includes(name)) {
             report(name, 'does not exist in this app’s roles', path);
             return false;
         }
@@ -654,8 +654,8 @@ function validateSecurity(definition, report) {
         }
         return;
     }
-    if ((!security.default || !security.roles) && !security.guest) {
-        report(definition, 'invalid security definition. Must define either guest or roles and default', ['security']);
+    if ((!security.default || !security.roles) && !security.guest && !security.cron) {
+        report(definition, 'invalid security definition. Must define either guest or cron or roles and default', ['security']);
         return;
     }
     if (security.guest) {
@@ -677,13 +677,38 @@ function validateSecurity(definition, report) {
             validatePermissions(definition, security.guest.permissions, inheritedPermissions, possibleGuestPermissions, report, ['security', 'guest']);
         }
     }
+    else if (security.cron) {
+        if (!definition.cron) {
+            report(definition, 'can not define cron definition without a cron job', ['security', 'cron']);
+            return;
+        }
+        if (security.cron.inherits && security.cron.inherits.length && !security.roles) {
+            report(definition, 'cron can not inherit roles if the roles property is not defined', [
+                'security',
+                'cron',
+                'inherits',
+            ]);
+            return;
+        }
+        const inheritedPermissions = getAppRolePermissions(security, security.cron.inherits || []);
+        const possibleCronPermissions = getAppPossibleGuestPermissions(definition);
+        if (inheritedPermissions.some((ip) => !possibleCronPermissions.includes(ip))) {
+            report(definition, 'invalid security definition. Guest cannot inherit roles that contain own resource permissions', ['security', 'cron', 'inherits']);
+            return;
+        }
+        if (security.cron.permissions) {
+            validatePermissions(definition, security.cron.permissions, inheritedPermissions, possibleCronPermissions, report, ['security', 'cron']);
+        }
+    }
     else {
+        // eslint-disable-next-line @typescript-eslint/prefer-ts-expect-error
+        // @ts-ignore 18048 variable is possibly undefined (strictNullChecks)
         checkRoleExists(security.default.role, ['security', 'default', 'role']);
     }
     if (security.roles) {
         const possibleAppPermissions = getAppPossiblePermissions(definition);
         for (const [name, role] of Object.entries(security.roles)) {
-            if (predefinedRoles.includes(name)) {
+            if ([...predefinedRoles, 'cron'].includes(name)) {
                 report(definition, `not allowed to overwrite role ${name}`, ['security', 'roles', name]);
             }
             const inheritedPermissions = [];
@@ -735,7 +760,7 @@ function validateHooks(definition, report) {
             if (!has(resource, actionType)) {
                 continue;
             }
-            const tos = resource[actionType].hooks?.notification?.to;
+            const tos = resource[actionType]?.hooks?.notification?.to;
             if (tos) {
                 for (const [index, to] of tos.entries()) {
                     if (to !== '$author' && !has(definition.security?.roles, to)) {
@@ -823,6 +848,10 @@ function validateActions(definition, report) {
                 report(action.type, 'action type is not supported for cron jobs', [...path, 'type']);
                 return;
             }
+            if (path[0] === 'webhooks' && !serverActions.has(action.type)) {
+                report(action.type, 'action type is not supported for webhooks', [...path, 'type']);
+                return;
+            }
             if (action.type.startsWith('app.member.') && !definition.security) {
                 report(action.type, 'refers to an app member action but the app doesn’t have a security definition', [...path, 'type']);
                 return;
@@ -943,6 +972,8 @@ function validateActions(definition, report) {
                     return;
                 }
                 const [toBase, toSub] = [].concat(to);
+                // @ts-expect-error 2345 argument of type is not assignable to parameter of type
+                // (strictNullChecks) - Severe
                 const toPage = findPageByName(definition.pages, toBase);
                 if (!toPage) {
                     report(to, 'refers to a page that doesn’t exist', [...path, 'to']);
@@ -1020,8 +1051,8 @@ function validateEvents(definition, blockVersions, report) {
             if (action.type === 'dialog') {
                 for (const block of action.blocks) {
                     const versions = blockVersions.get(normalizeBlockName(block.type));
-                    const version = versions.get(block.version);
-                    if (version.layout === 'float') {
+                    const version = versions?.get(block.version);
+                    if (version?.layout === 'float') {
                         report(block.version, 'block with layout type: "'
                             .concat(version.layout)
                             .concat('" is not allowed in a dialog action'), [...path, 'type']);
@@ -1038,7 +1069,7 @@ function validateEvents(definition, blockVersions, report) {
                 return;
             }
             collect([...path, 'event'], action.event, true);
-            if ('waitFor' in action) {
+            if ('waitFor' in action && action.waitFor) {
                 collect([...path, 'waitFor'], action.waitFor, false);
             }
         },
@@ -1046,12 +1077,12 @@ function validateEvents(definition, blockVersions, report) {
             if (!(page.type === 'tabs') || page.tabs) {
                 return;
             }
-            if (page.definition.events.emit) {
+            if (page.definition?.events.emit) {
                 for (const [prefix, name] of Object.entries(page.definition.events.emit)) {
                     collect([...path, 'events', 'emit', prefix], name, true);
                 }
             }
-            if (page.definition.events.listen) {
+            if (page.definition?.events.listen) {
                 for (const [prefix, name] of Object.entries(page.definition.events.listen)) {
                     collect([...path, 'events', 'listen', prefix], name, false);
                 }
@@ -1078,6 +1109,8 @@ function validateEvents(definition, blockVersions, report) {
         listeners: new Map(),
     };
     if (indexMap.has('controller')) {
+        // eslint-disable-next-line @typescript-eslint/prefer-ts-expect-error
+        // @ts-ignore 2322 null is not assignable to type (strictNullChecks)
         controllerEvents = { ...indexMap.get('controller') };
     }
     indexMap.delete('controller');
@@ -1159,6 +1192,9 @@ export async function validateAppDefinition(definition, getBlockVersions, contro
         result.errors.push(new ValidationError(message, instance, undefined, path));
     };
     try {
+        // eslint-disable-next-line @typescript-eslint/prefer-ts-expect-error
+        // @ts-ignore 2345 argument of type is not assignable to parameter of type
+        // (strictNullChecks)
         validateController(definition, controllerImplementations, report);
         validateCronJobs(definition, report);
         validateDefaultPage(definition, report);

package/api/components/parameters/trainingBlockId.d.ts

@@ -1,2 +0,0 @@
-import { type OpenAPIV3 } from 'openapi-types';
-export declare const trainingBlockId: OpenAPIV3.ParameterObject;

package/api/components/parameters/trainingBlockId.js

@@ -1,8 +0,0 @@
-export const trainingBlockId = {
-    name: 'trainingBlockId',
-    in: 'path',
-    description: 'Id of the trainingBlock on which the operation will be performed.',
-    required: true,
-    schema: { $ref: '#/components/schemas/TrainingBlock/properties/id' },
-};
-//# sourceMappingURL=trainingBlockId.js.map

package/api/components/schemas/TrainingBlock.d.ts

@@ -1,2 +0,0 @@
-import { type OpenAPIV3 } from 'openapi-types';
-export declare const TrainingBlock: OpenAPIV3.NonArraySchemaObject;

package/api/components/schemas/TrainingBlock.js

@@ -1,38 +0,0 @@
-export const TrainingBlock = {
-    type: 'object',
-    description: '',
-    additionalProperties: false,
-    properties: {
-        id: {
-            type: 'string',
-            description: 'The id of the Training Block, will be generated automatically by the system.',
-            readOnly: true,
-        },
-        trainingId: {
-            type: 'number',
-            minimum: 0,
-            description: 'Id of the parent training.',
-        },
-        title: {
-            type: 'string',
-            description: 'Title of the training block.',
-        },
-        documentationLink: {
-            type: 'string',
-            description: 'A URL pointing to a page in the documentation.',
-        },
-        videoLink: {
-            type: 'string',
-            description: 'Link of the video associated with the training block.',
-        },
-        exampleCode: {
-            type: 'string',
-            description: 'Example code for the user to be copied.',
-        },
-        externalResource: {
-            type: 'string',
-            description: 'Link to any external resource.',
-        },
-    },
-};
-//# sourceMappingURL=TrainingBlock.js.map

package/api/components/securitySchemes/cli.test.d.ts

@@ -1 +0,0 @@
-export {};

package/api/components/securitySchemes/cli.test.js

@@ -1,7 +0,0 @@
-import { expect, it } from 'vitest';
-import { cli } from './cli.js';
-import { scopes } from '../../../constants/index.js';
-it('should match the known scopes defined in utils', () => {
-    expect(Object.keys(cli.flows.clientCredentials.scopes)).toStrictEqual(scopes);
-});
-//# sourceMappingURL=cli.test.js.map

package/api/index.test.d.ts

@@ -1 +0,0 @@
-export {};