@appsemble/lang-sdk 0.33.7

package/schemas/json/JSONSchemaEnum.js

@@ -0,0 +1,36 @@
+import { BaseJSONSchema } from './BaseJSONSchema.js';
+import { extendJSONSchema } from '../utils/extendJSONSchema.js';
+export const JSONSchemaEnum = extendJSONSchema(BaseJSONSchema, {
+    type: 'object',
+    description: 'A JSON schema for an enum.',
+    additionalProperties: false,
+    required: ['enum'],
+    properties: {
+        enum: {
+            type: 'array',
+            description: 'A specific set of values this property is allowed to have.',
+            items: {
+                anyOf: [{ type: 'boolean' }, { type: 'number' }, { type: 'string' }, { enum: [null] }],
+            },
+        },
+        enumDescriptions: {
+            type: 'array',
+            description: `An array is descriptions for the enum values.
+
+The description is applied to the enum value at the same index.`,
+            items: { type: 'string' },
+        },
+        examples: {
+            type: 'array',
+            items: {
+                anyOf: [{ type: 'boolean' }, { type: 'number' }, { type: 'string' }, { enum: [null] }],
+                description: 'An example which is valid according to this schema.',
+            },
+        },
+        default: {
+            anyOf: [{ type: 'boolean' }, { type: 'number' }, { type: 'string' }, { enum: [null] }],
+            description: 'The default value which is used if no value is supplied.',
+        },
+    },
+});
+//# sourceMappingURL=JSONSchemaEnum.js.map

package/schemas/json/JSONSchemaInteger.d.ts

@@ -0,0 +1 @@
+export declare const JSONSchemaInteger: import("openapi-types").OpenAPIV3.SchemaObject;

package/schemas/json/JSONSchemaInteger.js

@@ -0,0 +1,55 @@
+import { BaseJSONSchema } from './BaseJSONSchema.js';
+import { extendJSONSchema } from '../utils/extendJSONSchema.js';
+export const JSONSchemaInteger = extendJSONSchema(BaseJSONSchema, {
+    type: 'object',
+    description: 'A JSON schema for an integer.',
+    additionalProperties: false,
+    required: ['type'],
+    properties: {
+        type: {
+            enum: ['integer'],
+            description: 'The type of the JSON schema. An integer means a fractionless number.',
+        },
+        examples: {
+            type: 'array',
+            items: {
+                type: 'integer',
+                description: 'An example integer which is valid according to this schema.',
+            },
+        },
+        default: {
+            type: 'integer',
+            description: 'The default value which is used if no value is supplied.',
+        },
+        enum: {
+            type: 'array',
+            description: 'If an enum is specified, the type can be safely removed.',
+            items: {
+                type: 'integer',
+            },
+        },
+        const: {
+            type: 'integer',
+            description: 'If const is specified, the type can be safely removed.',
+        },
+        minimum: {
+            type: 'integer',
+            description: 'The minimum value of the number.',
+            example: 0,
+        },
+        maximum: {
+            type: 'integer',
+            description: 'The maximum value of the number.',
+            example: 100,
+        },
+        multipleOf: {
+            type: 'integer',
+            description: `The value must be a multiple of this number.
+
+For example, if this is set to 3, then the values 0, 3, 6, 9, etc. will be allowed, but not 1, 2, 4,
+5, 7, 8, etc.
+`,
+        },
+    },
+});
+//# sourceMappingURL=JSONSchemaInteger.js.map

package/schemas/json/JSONSchemaMultiType.d.ts

@@ -0,0 +1 @@
+export declare const JSONSchemaMultiType: import("openapi-types").OpenAPIV3.SchemaObject;

package/schemas/json/JSONSchemaMultiType.js

@@ -0,0 +1,48 @@
+import { BaseJSONSchema } from './BaseJSONSchema.js';
+import { JSONSchemaArray } from './JSONSchemaArray.js';
+import { JSONSchemaInteger } from './JSONSchemaInteger.js';
+import { JSONSchemaObject } from './JSONSchemaObject.js';
+import { JSONSchemaString } from './JSONSchemaString.js';
+import { extendJSONSchema } from '../utils/extendJSONSchema.js';
+export const JSONSchemaMultiType = extendJSONSchema(BaseJSONSchema, {
+    type: 'object',
+    description: 'A JSON schema which defines multiple types.',
+    additionalProperties: false,
+    required: ['type'],
+    properties: {
+        type: {
+            type: 'array',
+            uniqueItems: true,
+            minItems: 2,
+            description: 'The type of the JSON schema. It’s recommended to use only one.',
+            items: {
+                enum: ['array', 'boolean', 'integer', 'null', 'number', 'string'],
+            },
+        },
+        examples: {
+            type: 'array',
+            description: 'An example which is valid according to this schema.',
+            items: {},
+        },
+        default: {
+            description: 'The default value which is used if no value is supplied.',
+        },
+        maxItems: JSONSchemaArray.properties.maxItems,
+        minItems: JSONSchemaArray.properties.minItems,
+        uniqueItems: JSONSchemaArray.properties.uniqueItems,
+        items: JSONSchemaArray.properties.items,
+        minimum: JSONSchemaInteger.properties.minimum,
+        maximum: JSONSchemaInteger.properties.maximum,
+        multipleOf: JSONSchemaInteger.properties.multipleOf,
+        maxProperties: JSONSchemaObject.properties.maxProperties,
+        minProperties: JSONSchemaObject.properties.minProperties,
+        properties: JSONSchemaObject.properties.properties,
+        required: JSONSchemaObject.properties.required,
+        additionalProperties: JSONSchemaObject.properties.additionalProperties,
+        format: JSONSchemaString.properties.format,
+        minLength: JSONSchemaString.properties.minLength,
+        maxLength: JSONSchemaString.properties.maxLength,
+        pattern: JSONSchemaString.properties.pattern,
+    },
+});
+//# sourceMappingURL=JSONSchemaMultiType.js.map

package/schemas/json/JSONSchemaNot.d.ts

@@ -0,0 +1 @@
+export declare const JSONSchemaNot: import("openapi-types").OpenAPIV3.SchemaObject;

package/schemas/json/JSONSchemaNot.js

@@ -0,0 +1,23 @@
+import { BaseJSONSchema } from './BaseJSONSchema.js';
+import { extendJSONSchema } from '../utils/extendJSONSchema.js';
+export const JSONSchemaNot = extendJSONSchema(BaseJSONSchema, {
+    type: 'object',
+    description: 'A JSON schema which may not be matched.',
+    additionalProperties: false,
+    required: ['not'],
+    properties: {
+        not: {
+            $ref: '#/components/schemas/JSONSchema',
+            description: 'The JSON schema which the value may not match.',
+        },
+        examples: {
+            type: 'array',
+            description: 'An example value which is valid according to this schema.',
+            items: {},
+        },
+        default: {
+            description: 'The default value which is used if no value is supplied.',
+        },
+    },
+});
+//# sourceMappingURL=JSONSchemaNot.js.map

package/schemas/json/JSONSchemaNull.d.ts

@@ -0,0 +1 @@
+export declare const JSONSchemaNull: import("openapi-types").OpenAPIV3.SchemaObject;

package/schemas/json/JSONSchemaNull.js

@@ -0,0 +1,16 @@
+import { BaseJSONSchema } from './BaseJSONSchema.js';
+import { extendJSONSchema } from '../utils/extendJSONSchema.js';
+// Although OpenAPI doesn’t support `null` as a value, JSON schema does.
+export const JSONSchemaNull = extendJSONSchema(BaseJSONSchema, {
+    type: 'object',
+    description: 'A JSON schema of type null only accepts a null value',
+    additionalProperties: false,
+    required: ['type'],
+    properties: {
+        type: {
+            enum: ['null'],
+            description: 'Only accept a null value.',
+        },
+    },
+});
+//# sourceMappingURL=JSONSchemaNull.js.map

package/schemas/json/JSONSchemaNumber.d.ts

@@ -0,0 +1 @@
+export declare const JSONSchemaNumber: import("openapi-types").OpenAPIV3.SchemaObject;

package/schemas/json/JSONSchemaNumber.js

@@ -0,0 +1,63 @@
+import { BaseJSONSchema } from './BaseJSONSchema.js';
+import { extendJSONSchema } from '../utils/extendJSONSchema.js';
+export const JSONSchemaNumber = extendJSONSchema(BaseJSONSchema, {
+    type: 'object',
+    description: 'A JSON schema for a number which has fractions.',
+    additionalProperties: false,
+    required: ['type'],
+    properties: {
+        type: {
+            enum: ['number'],
+            description: 'The type of the JSON schema. A number represents a number which has fractions. For fractionless numbers, use `integer` instead.',
+        },
+        enum: {
+            type: 'array',
+            description: 'If an enum is specified, the type can be safely removed.',
+            items: {
+                type: 'number',
+            },
+        },
+        const: {
+            type: 'number',
+            description: 'If const is specified, the type can be safely removed.',
+        },
+        examples: {
+            type: 'array',
+            items: {
+                type: 'number',
+                description: 'An example number which is valid according to this schema.',
+            },
+        },
+        default: {
+            type: 'number',
+            description: 'The default value which is used if no value is supplied.',
+        },
+        minimum: {
+            type: 'number',
+            description: 'The minimum value of the number.',
+            example: 0,
+        },
+        maximum: {
+            type: 'number',
+            description: 'The maximum value of the number.',
+            example: 100,
+        },
+        exclusiveMinimum: {
+            type: 'number',
+            description: 'The value must be bigger than this number. The given value itself is not allowed.',
+        },
+        exclusiveMaximum: {
+            type: 'number',
+            description: 'The value must be smaller than this number. The given value itself is not allowed.',
+        },
+        multipleOf: {
+            type: 'number',
+            description: `The value must be a multiple of this number.
+
+For example, if this is set to 0.5, then the values 0, 0.5, 1, 1.5, 2, 2.5, etc. will be allowed,
+but not 0.3, 1.7, etc.
+`,
+        },
+    },
+});
+//# sourceMappingURL=JSONSchemaNumber.js.map

package/schemas/json/JSONSchemaObject.d.ts

@@ -0,0 +1 @@
+export declare const JSONSchemaObject: import("openapi-types").OpenAPIV3.SchemaObject;

package/schemas/json/JSONSchemaObject.js

@@ -0,0 +1,74 @@
+import { BaseJSONSchema } from './BaseJSONSchema.js';
+import { extendJSONSchema } from '../utils/extendJSONSchema.js';
+export const JSONSchemaObject = extendJSONSchema(BaseJSONSchema, {
+    type: 'object',
+    description: 'A JSON schema for an object.',
+    additionalProperties: false,
+    required: ['type', 'additionalProperties'],
+    properties: {
+        type: {
+            enum: ['object'],
+            description: 'The type of the JSON schema.',
+        },
+        examples: {
+            type: 'array',
+            items: {
+                type: 'object',
+                description: 'An example object which is valid according to this schema.',
+                additionalProperties: true,
+            },
+        },
+        default: {
+            type: 'object',
+            description: 'The default value which is used if no value is supplied.',
+            additionalProperties: true,
+        },
+        maxProperties: {
+            type: 'integer',
+            description: 'The maximum number of properties the object is allowed to have.',
+            minimum: 0,
+        },
+        minProperties: {
+            type: 'integer',
+            description: 'The minimum number of properties the object is must have.',
+            minimum: 1,
+        },
+        required: {
+            type: 'array',
+            description: 'A list of properties that are required.',
+            minItems: 1,
+            items: {
+                type: 'string',
+                description: 'A property name which is required on the object.',
+            },
+        },
+        properties: {
+            type: 'object',
+            description: 'A mapping of object keys for the object to nested JSON schemas.',
+            additionalProperties: {
+                $ref: '#/components/schemas/JSONSchema',
+            },
+        },
+        additionalProperties: {
+            description: `Describe if this object is allowed to have properties besides those defined in \`properties\`
+
+It’s recommended to set this to \`false\`.
+`,
+            example: false,
+            anyOf: [
+                {
+                    type: 'boolean',
+                    description: `If false, the object may not have any additional properties.
+
+If true, the object may have **any** type of additional properties. This is **not** recommended.
+`,
+                },
+                {
+                    $ref: '#/components/schemas/JSONSchema',
+                    description: 'If this is a JSON schema, it describes any additional properties.',
+                },
+            ],
+        },
+    },
+});
+//# sourceMappingURL=JSONSchemaObject.js.map

package/schemas/json/JSONSchemaOneOf.d.ts

@@ -0,0 +1 @@
+export declare const JSONSchemaOneOf: import("openapi-types").OpenAPIV3.SchemaObject;

package/schemas/json/JSONSchemaOneOf.js

@@ -0,0 +1,24 @@
+import { BaseJSONSchema } from './BaseJSONSchema.js';
+import { extendJSONSchema } from '../utils/extendJSONSchema.js';
+export const JSONSchemaOneOf = extendJSONSchema(BaseJSONSchema, {
+    type: 'object',
+    description: 'A JSON schema which determines the value must match exactly one of the given schemas.',
+    additionalProperties: false,
+    required: ['oneOf'],
+    properties: {
+        oneOf: {
+            type: 'array',
+            description: 'The JSON schema must match exactly one of the given schemas.',
+            items: {
+                $ref: '#/components/schemas/JSONSchema',
+            },
+        },
+        example: {
+            description: 'An example value which is valid according to this schema.',
+        },
+        default: {
+            description: 'The default value which is used if no value is supplied.',
+        },
+    },
+});
+//# sourceMappingURL=JSONSchemaOneOf.js.map

package/schemas/json/JSONSchemaRemapper.d.ts

@@ -0,0 +1 @@
+export declare const JSONSchemaRemapper: import("openapi-types").OpenAPIV3.SchemaObject;

package/schemas/json/JSONSchemaRemapper.js

@@ -0,0 +1,19 @@
+import { BaseJSONSchema } from './BaseJSONSchema.js';
+import { extendJSONSchema } from '../utils/extendJSONSchema.js';
+// Allow remappers without specifying a type.
+export const JSONSchemaRemapper = extendJSONSchema(BaseJSONSchema, {
+    type: 'object',
+    description: 'A JSON schema which allows a format of remapper without a type.',
+    additionalProperties: false,
+    required: ['format'],
+    properties: {
+        format: {
+            enum: ['remapper'],
+            description: 'Allow a remapper definition. This is supported for blocks only.',
+        },
+        default: {
+            $ref: '#/components/schemas/RemapperDefinition',
+        },
+    },
+});
+//# sourceMappingURL=JSONSchemaRemapper.js.map

package/schemas/json/JSONSchemaRoot.d.ts

@@ -0,0 +1 @@
+export declare const JSONSchemaRoot: import("openapi-types").OpenAPIV3.SchemaObject;

package/schemas/json/JSONSchemaRoot.js

@@ -0,0 +1,21 @@
+import { JSONSchemaObject } from './JSONSchemaObject.js';
+import { extendJSONSchema } from '../utils/extendJSONSchema.js';
+export const JSONSchemaRoot = extendJSONSchema(JSONSchemaObject, {
+    type: 'object',
+    description: 'A top level JSON schema.',
+    additionalProperties: false,
+    properties: {
+        definitions: {
+            description: 'This property may be used to store JSON schemas that may be referenced from other places.',
+            additionalProperties: {
+                $ref: '#/components/schemas/JSONSchema',
+            },
+        },
+        $schema: {
+            description: 'The JSON schema meta schema. You probably don’t need to specify this explicitly.',
+            enum: ['http://json-schema.org/draft-04/schema#', 'http://json-schema.org/draft-07/schema#'],
+            default: 'http://json-schema.org/draft-07/schema#',
+        },
+    },
+});
+//# sourceMappingURL=JSONSchemaRoot.js.map

package/schemas/json/JSONSchemaString.d.ts

@@ -0,0 +1 @@
+export declare const JSONSchemaString: import("openapi-types").OpenAPIV3.SchemaObject;

package/schemas/json/JSONSchemaString.js

@@ -0,0 +1,107 @@
+import { BaseJSONSchema } from './BaseJSONSchema.js';
+import { extendJSONSchema } from '../utils/extendJSONSchema.js';
+export const JSONSchemaString = extendJSONSchema(BaseJSONSchema, {
+    type: 'object',
+    description: 'A JSON schema for a string.',
+    additionalProperties: false,
+    required: ['type'],
+    properties: {
+        type: {
+            enum: ['string'],
+            description: 'The type of the JSON schema. A string is the technical term for a piece of text.',
+        },
+        examples: {
+            type: 'array',
+            items: {
+                type: 'string',
+                description: 'An example string which is valid according to this schema.',
+            },
+        },
+        default: {
+            type: 'string',
+            description: 'The default value which is used if no value is supplied.',
+        },
+        enum: {
+            type: 'array',
+            description: 'If an enum is specified, the type can be safely removed.',
+            items: {
+                type: 'string',
+            },
+        },
+        const: {
+            type: 'string',
+            description: 'If const is specified, the type can be safely removed.',
+        },
+        format: {
+            // https://json-schema.org/understanding-json-schema/reference/string.html#built-in-formats
+            enum: [
+                // https://json-schema.org/understanding-json-schema/reference/string.html#dates-and-times
+                'date-time',
+                'time',
+                'date',
+                'duration',
+                // https://json-schema.org/understanding-json-schema/reference/string.html#email-addresses
+                'email',
+                'idn-email',
+                // https://json-schema.org/understanding-json-schema/reference/string.html#hostnames
+                'hostname',
+                'idn-hostname',
+                // https://json-schema.org/understanding-json-schema/reference/string.html#ip-addresses
+                'ipv4',
+                'ipv6',
+                // https://json-schema.org/understanding-json-schema/reference/string.html#resource-identifiers
+                'uuid',
+                'uri',
+                'uri-reference',
+                'iri',
+                'iri-reference',
+                // https://json-schema.org/understanding-json-schema/reference/string.html#uri-template
+                'uri-template',
+                // https://json-schema.org/understanding-json-schema/reference/string.html#json-pointer
+                'json-pointer',
+                'relative-json-pointer',
+                // https://json-schema.org/understanding-json-schema/reference/string.html#index-12
+                'regex',
+                // Custom
+                'action',
+                'binary',
+                'event-emitter',
+                'event-listener',
+                'fontawesome',
+            ],
+            description: 'The format values should adhere to.',
+        },
+        minLength: {
+            type: 'integer',
+            description: 'The minimum length of the string.',
+            minimum: 1,
+        },
+        maxLength: {
+            type: 'integer',
+            description: `The maximum length of the string.
+
+It’s highly recommended to set this property, even if it’s a big number. For example 5000 characters
+is plenty for most larger input fields. Not doing so may result in extremely large user input, which
+results in a bad user experience.
+`,
+            minimum: 1,
+            example: 5000,
+        },
+        pattern: {
+            type: 'string',
+            description: `A regular expression to describe user input.
+
+Regular expressions are a powerful way to enforce proper user input, but the learning curve is high.
+If you don’t know what this is, we recommend to omit this field for now.
+`,
+            minLength: 1,
+            format: 'regex',
+        },
+        multiline: {
+            type: 'boolean',
+            description: 'If true, Appsemble renders a textarea in the graphical JSON editor.',
+            default: false,
+        },
+    },
+});
+//# sourceMappingURL=JSONSchemaString.js.map

package/schemas/utils/extendJSONSchema.d.ts

@@ -0,0 +1,13 @@
+import { type OpenAPIV3 } from 'openapi-types';
+/**
+ * Extend a JSON schema by copying its properties.
+ *
+ * This creates a new schema based on the input schema, where `required` and `properties` are
+ * inherited from the `base` schema.
+ *
+ * @param base The base schema whose properties to inherit.
+ * @param schema The schema overriding the base schema.
+ * @param omit Properties to omit from the base schema.
+ * @returns The schema which extends the base schema.
+ */
+export declare function extendJSONSchema(base: OpenAPIV3.SchemaObject, schema: OpenAPIV3.SchemaObject, omit?: string[]): OpenAPIV3.SchemaObject;

package/schemas/utils/extendJSONSchema.js

@@ -0,0 +1,34 @@
+import { has } from '../../miscellaneous.js';
+/**
+ * Extend a JSON schema by copying its properties.
+ *
+ * This creates a new schema based on the input schema, where `required` and `properties` are
+ * inherited from the `base` schema.
+ *
+ * @param base The base schema whose properties to inherit.
+ * @param schema The schema overriding the base schema.
+ * @param omit Properties to omit from the base schema.
+ * @returns The schema which extends the base schema.
+ */
+export function extendJSONSchema(base, schema, omit = []) {
+    const result = { ...schema };
+    const required = Array.isArray(schema.required) ? [...schema.required] : [];
+    if (Array.isArray(base.required)) {
+        for (const name of base.required) {
+            if (!required.includes(name) && !omit.includes(name)) {
+                required.push(name);
+            }
+        }
+    }
+    if (required.length) {
+        result.required = required;
+    }
+    result.properties = { ...schema.properties };
+    for (const [name, property] of Object.entries(base.properties ?? {})) {
+        if (!omit.includes(name) && !has(result.properties, name)) {
+            result.properties[name] = property;
+        }
+    }
+    return result;
+}
+//# sourceMappingURL=extendJSONSchema.js.map

package/serverActions.d.ts

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

package/serverActions.js

@@ -0,0 +1,21 @@
+export const serverActions = new Set([
+    'noop',
+    'throw',
+    'condition',
+    'each',
+    'email',
+    'log',
+    'notify',
+    'request',
+    'resource.get',
+    'resource.query',
+    'resource.create',
+    'resource.patch',
+    'resource.update',
+    'resource.delete',
+    'resource.delete.all',
+    'resource.delete.bulk',
+    'static',
+    'app.member.query',
+]);
+//# sourceMappingURL=serverActions.js.map

package/string.d.ts

@@ -0,0 +1,23 @@
+/**
+ * A minimalist implementation to convert camel case strings to hyphenated ones.
+ *
+ * @param string The camel case input.
+ * @returns The input, but hyphenated.
+ */
+export declare function camelToHyphen(string: string): string;
+/**
+ * Convert a string to upper case.
+ *
+ * @param input The string to convert to upper case.
+ * @returns The input, but upper case.
+ */
+export declare function toUpperCase(input: string): string;
+/**
+ * Escape a JSON reference.
+ *
+ * See https://tools.ietf.org/html/rfc6901#section-3
+ *
+ * @param ref The JSON pointer segment to escape.
+ * @returns The escaped JSON pointer segment.
+ */
+export declare function decodeJSONRef(ref: string): string;

package/string.js

@@ -0,0 +1,30 @@
+/**
+ * A minimalist implementation to convert camel case strings to hyphenated ones.
+ *
+ * @param string The camel case input.
+ * @returns The input, but hyphenated.
+ */
+export function camelToHyphen(string) {
+    return string.replaceAll(/[A-Z]/g, (match) => `-${match.toLowerCase()}`);
+}
+/**
+ * Convert a string to upper case.
+ *
+ * @param input The string to convert to upper case.
+ * @returns The input, but upper case.
+ */
+export function toUpperCase(input) {
+    return input.toUpperCase();
+}
+/**
+ * Escape a JSON reference.
+ *
+ * See https://tools.ietf.org/html/rfc6901#section-3
+ *
+ * @param ref The JSON pointer segment to escape.
+ * @returns The escaped JSON pointer segment.
+ */
+export function decodeJSONRef(ref) {
+    return decodeURIComponent(ref).replaceAll('~1', '/').replaceAll('~0', '~');
+}
+//# sourceMappingURL=string.js.map