@shaclmate/compiler 4.0.94 → 4.0.96

package/dist/generators/ts/_AbstractIntersectionType/AbstractIntersectionType_equalsFunction.d.ts

@@ -0,0 +1,5 @@
+import type { AbstractIntersectionType } from "../AbstractIntersectionType.js";
+import type { Type } from "../Type.js";
+import { type Code } from "../ts-poet-wrapper.js";
+export declare function AbstractIntersectionType_equalsFunctionExpression<MemberTypeT extends Type>(this: AbstractIntersectionType<MemberTypeT>): Code;
+//# sourceMappingURL=AbstractIntersectionType_equalsFunction.d.ts.map

package/dist/generators/ts/_AbstractIntersectionType/AbstractIntersectionType_equalsFunction.js

@@ -0,0 +1,7 @@
+import { code, joinCode } from "../ts-poet-wrapper.js";
+export function AbstractIntersectionType_equalsFunctionExpression() {
+    return code `\
+(left, right) =>
+${joinCode(this.members.map(({ type }) => code `${type.equalsFunction.annotatedUsage}(left, right)`), { on: " && " })}`;
+}
+//# sourceMappingURL=AbstractIntersectionType_equalsFunction.js.map

package/dist/generators/ts/_AbstractIntersectionType/AbstractIntersectionType_filterFunction.d.ts

@@ -0,0 +1,5 @@
+import type { AbstractIntersectionType } from "../AbstractIntersectionType.js";
+import type { Type } from "../Type.js";
+import { type Code } from "../ts-poet-wrapper.js";
+export declare function AbstractIntersectionType_filterFunctionExpression<MemberTypeT extends Type>(this: AbstractIntersectionType<MemberTypeT>): Code;
+//# sourceMappingURL=AbstractIntersectionType_filterFunction.d.ts.map

package/dist/generators/ts/_AbstractIntersectionType/AbstractIntersectionType_filterFunction.js

@@ -0,0 +1,7 @@
+import { code, joinCode } from "../ts-poet-wrapper.js";
+export function AbstractIntersectionType_filterFunctionExpression() {
+    return code `\
+(filter, value) =>
+  ${joinCode(this.members.map(({ type }) => code `${type.filterFunction.annotatedUsage}(filter, value)`), { on: " && " })}`;
+}
+//# sourceMappingURL=AbstractIntersectionType_filterFunction.js.map

package/dist/generators/ts/_AbstractIntersectionType/AbstractIntersectionType_hashFunction.d.ts

@@ -0,0 +1,5 @@
+import type { AbstractIntersectionType } from "../AbstractIntersectionType.js";
+import type { Type } from "../Type.js";
+import { type Code } from "../ts-poet-wrapper.js";
+export declare function AbstractIntersectionType_hashFunctionExpression<MemberTypeT extends Type>(this: AbstractIntersectionType<MemberTypeT>): Code;
+//# sourceMappingURL=AbstractIntersectionType_hashFunction.d.ts.map

package/dist/generators/ts/_AbstractIntersectionType/AbstractIntersectionType_hashFunction.js

@@ -0,0 +1,8 @@
+import { code, joinCode } from "../ts-poet-wrapper.js";
+export function AbstractIntersectionType_hashFunctionExpression() {
+    return code `\
+(hasher, value) => {
+${joinCode(this.members.map(({ type }) => code `${type.hashFunction.annotatedUsage}(hasher, value);`))}
+}`;
+}
+//# sourceMappingURL=AbstractIntersectionType_hashFunction.js.map

package/dist/generators/ts/_AbstractIntersectionType/AbstractIntersectionType_toLoggableFunction.d.ts

@@ -0,0 +1,5 @@
+import type { AbstractIntersectionType } from "../AbstractIntersectionType.js";
+import type { Type } from "../Type.js";
+import { type Code } from "../ts-poet-wrapper.js";
+export declare function AbstractIntersectionType_toLoggableFunctionExpression<MemberTypeT extends Type>(this: AbstractIntersectionType<MemberTypeT>): Code;
+//# sourceMappingURL=AbstractIntersectionType_toLoggableFunction.d.ts.map

package/dist/generators/ts/_AbstractIntersectionType/AbstractIntersectionType_toLoggableFunction.js

@@ -0,0 +1,14 @@
+import { codeEquals } from "../codeEquals.js";
+import { code, joinCode } from "../ts-poet-wrapper.js";
+export function AbstractIntersectionType_toLoggableFunctionExpression() {
+    const memberToLoggableExpressions = this.members.map(({ type }) => type.toLoggableExpression({
+        variables: { value: code `value` },
+    }));
+    // If every toLoggable expression is the same, use that expression and don't bother discriminating the member type.
+    if (memberToLoggableExpressions.every((memberToLoggableExpression, memberI) => memberI === 0 ||
+        codeEquals(memberToLoggableExpression, memberToLoggableExpressions[0]))) {
+        return code `(value) => ${memberToLoggableExpressions[0]}`;
+    }
+    return code `(value) => [${joinCode(memberToLoggableExpressions, { on: "," })}]`;
+}
+//# sourceMappingURL=AbstractIntersectionType_toLoggableFunction.js.map

package/dist/generators/ts/_AbstractIntersectionType/AbstractIntersectionType_toStringFunction.d.ts

@@ -0,0 +1,5 @@
+import type { AbstractIntersectionType } from "../AbstractIntersectionType.js";
+import type { Type } from "../Type.js";
+import { type Code } from "../ts-poet-wrapper.js";
+export declare function AbstractIntersectionType_toStringFunctionExpression<MemberTypeT extends Type>(this: AbstractIntersectionType<MemberTypeT>): Code;
+//# sourceMappingURL=AbstractIntersectionType_toStringFunction.d.ts.map

package/dist/generators/ts/_AbstractIntersectionType/AbstractIntersectionType_toStringFunction.js

@@ -0,0 +1,17 @@
+import { codeEquals } from "../codeEquals.js";
+import { code, joinCode } from "../ts-poet-wrapper.js";
+export function AbstractIntersectionType_toStringFunctionExpression() {
+    const memberToStringExpressions = this.members.map(({ type }) => type.toStringExpression({
+        variables: { value: code `value` },
+    }));
+    // If every toString expression is the same, use that expression and don't bother discriminating the member type.
+    if (memberToStringExpressions.every((memberToStringExpression, memberI) => memberI === 0 ||
+        codeEquals(memberToStringExpression, memberToStringExpressions[0]))) {
+        return code `(value) => ${memberToStringExpressions[0]}`;
+    }
+    return code `\
+(value) => JSON.stringify([${joinCode(this.members.map(({ type }) => type.toStringExpression({
+        variables: { value: code `value` },
+    })), { on: ", " })}])`;
+}
+//# sourceMappingURL=AbstractIntersectionType_toStringFunction.js.map

package/dist/generators/ts/_AbstractIntersectionType/AbstractIntersectionType_valueSparqlConstructTriplesFunction.d.ts

@@ -0,0 +1,5 @@
+import type { AbstractIntersectionType } from "../AbstractIntersectionType.js";
+import type { Type } from "../Type.js";
+import { type Code } from "../ts-poet-wrapper.js";
+export declare function AbstractIntersectionType_valueSparqlConstructTriplesFunctionExpression<MemberTypeT extends Type>(this: AbstractIntersectionType<MemberTypeT>): Code;
+//# sourceMappingURL=AbstractIntersectionType_valueSparqlConstructTriplesFunction.d.ts.map

package/dist/generators/ts/_AbstractIntersectionType/AbstractIntersectionType_valueSparqlConstructTriplesFunction.js

@@ -0,0 +1,13 @@
+import { code, joinCode, literalOf } from "../ts-poet-wrapper.js";
+export function AbstractIntersectionType_valueSparqlConstructTriplesFunctionExpression() {
+    return code `\
+({ ignoreRdfType, filter, schema, ...otherParameters }) => {
+  let triples: ${this.reusables.imports.sparqljs}.Triple[] = [];
+
+  ${joinCode(this.members.map(({ type }, memberI) => code `\
+triples = triples.concat(${type.valueSparqlConstructTriplesFunction.annotatedUsage}({ ...otherParameters, filter, ignoreRdfType: true, schema: schema.members[${literalOf(memberI)}] }));`))}
+  
+  return triples;
+}`;
+}
+//# sourceMappingURL=AbstractIntersectionType_valueSparqlConstructTriplesFunction.js.map

package/dist/generators/ts/_AbstractIntersectionType/AbstractIntersectionType_valueSparqlWherePatternsFunction.d.ts

@@ -0,0 +1,5 @@
+import type { AbstractIntersectionType } from "../AbstractIntersectionType.js";
+import type { Type } from "../Type.js";
+import { type Code } from "../ts-poet-wrapper.js";
+export declare function AbstractIntersectionType_valueSparqlWherePatternsFunctionExpression<MemberTypeT extends Type>(this: AbstractIntersectionType<MemberTypeT>): Code;
+//# sourceMappingURL=AbstractIntersectionType_valueSparqlWherePatternsFunction.d.ts.map

package/dist/generators/ts/_AbstractIntersectionType/AbstractIntersectionType_valueSparqlWherePatternsFunction.js

@@ -0,0 +1,13 @@
+import { code, joinCode, literalOf } from "../ts-poet-wrapper.js";
+export function AbstractIntersectionType_valueSparqlWherePatternsFunctionExpression() {
+    return code `\
+({ filter, schema, ...otherParameters }) => {
+  let intersectionPatterns: ${this.reusables.snippets.SparqlPattern}[] = [];
+
+  ${joinCode(this.members.map(({ type }, memberI) => code `\
+intersectionPatterns = intersectionPatterns.concat(${type.valueSparqlWherePatternsFunction.annotatedUsage}({ ...otherParameters, filter, ignoreRdfType: true, schema: schema.members[${literalOf(memberI)}] }));`))}
+  
+  return intersectionPatterns;
+}`;
+}
+//# sourceMappingURL=AbstractIntersectionType_valueSparqlWherePatternsFunction.js.map

package/dist/generators/ts/_AbstractType/AbstractType_DiscriminatedType.d.ts

@@ -0,0 +1,9 @@
+import type { Code } from "../ts-poet-wrapper.js";
+export interface AbstractType_DiscriminatedType {
+    readonly discriminantProperty: {
+        readonly name: string;
+        readonly values: readonly (number | string)[];
+    };
+    readonly expression: Code;
+}
+//# sourceMappingURL=AbstractType_DiscriminatedType.d.ts.map

package/dist/generators/ts/_AbstractType/AbstractType_DiscriminatedType.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=AbstractType_DiscriminatedType.js.map

package/dist/generators/ts/_AbstractType/AbstractType_JsonType.d.ts

@@ -1,16 +1,201 @@
+import { Maybe } from "purify-ts";
+import type { Reusables } from "../Reusables.js";
+import type { Snippet } from "../Snippet.js";
+import type { TsGenerator } from "../TsGenerator.js";
 import { type Code } from "../ts-poet-wrapper.js";
-export declare class AbstractType_JsonType {
-    /**
-     * Is the type optional in JSON? Equivalent to ? in TypeScript or | undefined.
-     */
-    readonly optional: boolean;
-    /**
-     * The expression of the type when it's required i.e. -- so it should never include "| undefined".
-     */
-    readonly requiredExpression: Code;
-    constructor(requiredExpression: Code, parameters?: {
-        optional: boolean;
+declare abstract class AbstractJsonType {
+    protected readonly configuration: TsGenerator.Configuration;
+    protected abstract readonly inlineExpression: Code;
+    protected readonly reusables: Reusables;
+    protected abstract readonly schemaExpression: Code;
+    protected readonly snippet: Maybe<Snippet>;
+    abstract readonly kind: string;
+    readonly name: Maybe<AbstractJsonType.Name>;
+    constructor({ configuration, name, snippet, reusables, }: {
+        configuration: TsGenerator.Configuration;
+        name: Maybe<AbstractJsonType.Name>;
+        snippet: Maybe<Snippet>;
+        reusables: Reusables;
     });
+    protected moduleDeclarations({ unqualifiedName, }: {
+        unqualifiedName: string;
+    }): Code[];
+    get declaration(): Maybe<Code>;
     get expression(): Code;
+    get schema(): Code;
+    uiSchemaElement(_parameters: {
+        variables: {
+            scopePrefix: Code;
+        };
+    }): Maybe<Code>;
 }
+declare abstract class AbstractJsonPrimitiveType<PrimitiveT extends boolean | number | string> extends AbstractJsonType {
+    readonly inReference: Maybe<Code>;
+    readonly in_: readonly PrimitiveT[];
+    protected abstract readonly typeof: "boolean" | "number" | "string";
+    constructor({ in_, inReference, ...superParameters }: {
+        in_: readonly PrimitiveT[];
+        inReference: Maybe<Code>;
+    } & ConstructorParameters<typeof AbstractJsonType>[0]);
+    protected get inlineExpression(): Code;
+    protected get schemaExpression(): Code;
+}
+declare class JsonArrayType extends AbstractJsonType {
+    readonly itemType: JsonType;
+    readonly kind = "JsonArray";
+    readonly minCount: bigint;
+    constructor({ itemType, minCount, ...superParameters }: {
+        itemType: JsonType;
+        minCount: bigint;
+    } & ConstructorParameters<typeof AbstractJsonType>[0]);
+    protected get inlineExpression(): Code;
+    protected get schemaExpression(): Code;
+}
+declare class JsonBooleanType extends AbstractJsonPrimitiveType<boolean> {
+    readonly kind = "JsonBoolean";
+    protected readonly typeof = "boolean";
+}
+declare class JsonDiscriminatedUnionType extends AbstractJsonType {
+    readonly kind = "JsonDiscriminatedUnion";
+    readonly members: readonly JsonDiscriminatedUnionType.Member[];
+    constructor({ members, ...superParameters }: {
+        members: readonly JsonDiscriminatedUnionType.Member[];
+        recursive: boolean;
+    } & ConstructorParameters<typeof AbstractJsonType>[0]);
+    protected get inlineExpression(): Code;
+    protected get schemaExpression(): Code;
+}
+declare namespace JsonDiscriminatedUnionType {
+    interface Member {
+        readonly discriminantValue: number | string;
+        readonly type: JsonIntersectionType | JsonObjectType;
+    }
+}
+declare class JsonIntersectionType extends AbstractJsonType {
+    readonly kind = "JsonIntersection";
+    readonly memberTypes: readonly JsonType[];
+    constructor({ memberTypes, ...superParameters }: {
+        memberTypes: readonly JsonType[];
+        recursive: boolean;
+    } & ConstructorParameters<typeof AbstractJsonType>[0]);
+    protected get inlineExpression(): Code;
+    protected get schemaExpression(): Code;
+}
+declare class JsonNumberType extends AbstractJsonPrimitiveType<number> {
+    readonly kind = "JsonNumber";
+    protected readonly typeof = "number";
+}
+declare class JsonObjectType extends AbstractJsonType {
+    readonly kind = "JsonObject";
+    readonly members: readonly JsonObjectType.Member[];
+    private readonly memberTypes;
+    constructor({ members, ...superParameters }: {
+        members: readonly JsonObjectType.Member[];
+    } & ConstructorParameters<typeof AbstractJsonType>[0]);
+    protected get inlineExpression(): Code;
+    protected get schemaExpression(): Code;
+    private get uiSchemaFunctionExpression();
+    private memberType;
+    protected moduleDeclarations(parameters: {
+        unqualifiedName: string;
+    }): Code[];
+    uiSchemaElement({ variables, }: Parameters<AbstractJsonType["uiSchemaElement"]>[0]): Maybe<Code>;
+}
+declare class JsonStringType extends AbstractJsonPrimitiveType<string> {
+    private readonly format;
+    private readonly minLength;
+    protected readonly typeof = "string";
+    readonly kind = "JsonString";
+    constructor({ format, minLength, ...superParameters }: {
+        format: Maybe<JsonStringType.Format>;
+        in_: readonly string[];
+        inReference: Maybe<Code>;
+        minLength: Maybe<bigint>;
+    } & ConstructorParameters<typeof AbstractJsonPrimitiveType<string>>[0]);
+    protected get schemaExpression(): Code;
+}
+declare class JsonTypeFactory {
+    private readonly constructorParameters;
+    constructor(constructorParameters: {
+        configuration: TsGenerator.Configuration;
+        reusables: Reusables;
+    });
+    createJsonArrayType(itemType: JsonType, options?: {
+        minCount?: bigint;
+        name?: AbstractJsonType.Name;
+        snippet?: Snippet;
+    }): JsonArrayType;
+    createJsonBooleanType(options?: {
+        in_?: readonly boolean[];
+        inReference?: Code;
+        name?: AbstractJsonType.Name;
+        snippet?: Snippet;
+    }): JsonBooleanType;
+    createJsonDiscriminatedUnionType(members: readonly JsonDiscriminatedUnionType.Member[], options?: {
+        name?: AbstractJsonType.Name;
+        recursive?: boolean;
+        snippet?: Snippet;
+    }): JsonDiscriminatedUnionType;
+    createJsonIntersectionType(memberTypes: readonly JsonType[], options?: {
+        name?: AbstractJsonType.Name;
+        recursive?: boolean;
+        snippet?: Snippet;
+    }): JsonIntersectionType;
+    createJsonNumberType(options?: {
+        in_?: readonly number[];
+        inReference?: Code;
+        name?: AbstractJsonType.Name;
+        snippet?: Snippet;
+    }): JsonNumberType;
+    createJsonObjectType(partialMembers: readonly JsonObjectType.PartialMember[] | Record<string, Omit<JsonObjectType.PartialMember, "name">>, options?: {
+        name?: AbstractJsonType.Name;
+        snippet?: Snippet;
+    }): JsonObjectType;
+    createJsonStringType(options?: {
+        format?: JsonStringType.Format;
+        in_?: readonly string[];
+        inReference?: Code;
+        minLength?: bigint;
+        name?: AbstractJsonType.Name;
+        snippet?: Snippet;
+    }): JsonStringType;
+}
+type JsonType = JsonArrayType | JsonBooleanType | JsonDiscriminatedUnionType | JsonIntersectionType | JsonNumberType | JsonObjectType | JsonStringType;
+export type AbstractType_JsonType = JsonType;
+export type AbstractType_JsonTypeFactory = JsonTypeFactory;
+export declare namespace AbstractJsonType {
+    type Name = readonly string[];
+}
+export declare const AbstractType_JsonTypeFactory: typeof JsonTypeFactory;
+declare namespace JsonObjectType {
+    type MemberUiSchemaElementFunction = (parameters: {
+        variables: {
+            scopePrefix: Code;
+        };
+    }) => Code;
+    export interface Member {
+        readonly description: Maybe<string>;
+        readonly label: Maybe<string>;
+        readonly name: string;
+        readonly optional: boolean;
+        readonly recursive: boolean;
+        readonly type: JsonType | (() => JsonType);
+        /**
+         * Element object (usually a control https://jsonforms.io/docs/uischema/controls) for a JSON Forms UI schema.
+         */
+        readonly uiSchemaElement: Maybe<MemberUiSchemaElementFunction>;
+    }
+    export type PartialMember = Pick<JsonObjectType.Member, "name" | "type"> & {
+        description?: Maybe<string> | string;
+        label?: Maybe<string> | string;
+        optional?: boolean;
+        recursive?: boolean;
+        uiSchemaElement?: Maybe<MemberUiSchemaElementFunction> | MemberUiSchemaElementFunction;
+    };
+    export {};
+}
+declare namespace JsonStringType {
+    type Format = "date" | "datetime";
+}
+export {};
 //# sourceMappingURL=AbstractType_JsonType.d.ts.map