@shaclmate/compiler 4.0.38 → 4.0.39

package/dist/generators/ts/AbstractLazyObjectType.js

@@ -8,7 +8,6 @@ import { Maybe } from "purify-ts";
 import { invariant } from "ts-invariant";
 import { Memoize } from "typescript-memoize";
 import { AbstractType } from "./AbstractType.js";
-import { removeUndefined } from "./removeUndefined.js";
 import { code, joinCode } from "./ts-poet-wrapper.js";
 export class AbstractLazyObjectType extends AbstractType {
     partialType;
@@ -16,6 +15,7 @@ export class AbstractLazyObjectType extends AbstractType {
     declaration = Maybe.empty();
     discriminantProperty = Maybe.empty();
     mutable = false;
+    referencesObjectType = true;
     typeofs = ["object"];
     validationFunction = Maybe.empty();
     constructor({ partialType, resolveType, ...superParameters }) {
@@ -26,9 +26,6 @@ export class AbstractLazyObjectType extends AbstractType {
     get equalsFunction() {
         return code `((left, right) => ${this.partialType.equalsFunction}(left.${this.runtimeClass.partialPropertyName}, right.${this.runtimeClass.partialPropertyName}))`;
     }
-    get hashFunction() {
-        return code `((hasher, value) => ${this.partialType.hashFunction}(hasher, value.${this.runtimeClass.partialPropertyName}))`;
-    }
     get filterFunction() {
         return code `((filter: ${this.filterType}, value: ${this.name}) => ${this.partialType.filterFunction}(filter, value.${this.runtimeClass.partialPropertyName}))`;
     }
@@ -38,38 +35,32 @@ export class AbstractLazyObjectType extends AbstractType {
     get graphqlType() {
         return this.resolveType.graphqlType;
     }
+    get hashFunction() {
+        return code `((hasher, value) => ${this.partialType.hashFunction}(hasher, value.${this.runtimeClass.partialPropertyName}))`;
+    }
     get name() {
         return this.runtimeClass.name;
     }
     get recursive() {
         return this.partialType.recursive;
     }
-    get schema() {
-        return code `${removeUndefined(this.schemaObject)}`;
+    get schemaInitializers() {
+        return super.schemaInitializers.concat(code `get partialType() { return ${this.partialType.schema}; }`);
     }
     get schemaType() {
         return code `${{
             kind: this.kind,
             partialType: this.partialType.schemaType,
-            resolveType: this.resolveType.schemaType,
         }}`;
     }
     get toRdfResourceValueTypes() {
         return this.partialType.toRdfResourceValueTypes;
     }
     get valueSparqlConstructTriplesFunction() {
-        return code `(({ schema, ...otherParameters }) => ${this.partialType.valueSparqlConstructTriplesFunction}({ ...otherParameters, schema: schema.partial() }))`;
+        return code `(({ schema, ...otherParameters }) => ${this.partialType.valueSparqlConstructTriplesFunction}({ ...otherParameters, schema: schema.partialType }))`;
     }
     get valueSparqlWherePatternsFunction() {
-        return code `(({ schema, ...otherParameters }) => ${this.partialType.valueSparqlWherePatternsFunction}({ ...otherParameters, schema: schema.partial() }))`;
-    }
-    get schemaObject() {
-        return {
-            ...super.schemaObject,
-            partial: code `() => (${this.partialType.schema})`,
-            // Commenting out to reduce schema size
-            // resolved: code`() => (${this.resolveType.schema})`,
-        };
+        return code `(({ schema, ...otherParameters }) => ${this.partialType.valueSparqlWherePatternsFunction}({ ...otherParameters, schema: schema.partialType }))`;
     }
     jsonSchema(parameters) {
         return this.partialType.jsonSchema(parameters);
@@ -102,21 +93,12 @@ export class AbstractLazyObjectType extends AbstractType {
             },
         });
     }
-    resolvedNamedObjectUnionTypeToPartialNamedObjectUnionTypeConversion({ resolvedNamedObjectUnionType, partialNamedObjectUnionType, variables, }) {
-        invariant(resolvedNamedObjectUnionType.members.length ===
-            partialNamedObjectUnionType.members.length);
-        const caseBlocks = resolvedNamedObjectUnionType.members.map(({ discriminantValues }, memberI) => {
-            return code `${discriminantValues.map((discriminantPropertyValue) => `case "${discriminantPropertyValue}":`).join("\n")} return ${partialNamedObjectUnionType.members[memberI].type.name}.create(${variables.resolvedObjectUnion});`;
-        });
-        caseBlocks.push(code `default: ${variables.resolvedObjectUnion} satisfies never; throw new Error("unrecognized type");`);
-        return code `switch (${variables.resolvedObjectUnion}.${resolvedNamedObjectUnionType.discriminantProperty.unsafeCoerce().name}) { ${joinCode(caseBlocks)} }`;
-    }
     resolveToPartialFunction({ partialType, resolveType, }) {
         if (partialType.kind === "NamedObjectType") {
             return code `${partialType.name}.createUnsafe`;
         }
-        invariant(partialType.kind === "NamedObjectUnionType");
-        invariant(resolveType.kind === "NamedObjectUnionType");
+        invariant(partialType.kind === "NamedObjectUnion");
+        invariant(resolveType.kind === "NamedObjectUnion");
         invariant(partialType.members.length === resolveType.members.length);
         const caseBlocks = resolveType.members.map(({ discriminantValues }, memberI) => {
             return code `${discriminantValues.map((discriminantPropertyValue) => `case "${discriminantPropertyValue}":`).join("\n")} return ${partialType.members[memberI].type.name}.createUnsafe(resolved);`;
@@ -124,19 +106,25 @@ export class AbstractLazyObjectType extends AbstractType {
         caseBlocks.push(code `default: resolved satisfies never; throw new Error("unrecognized type");`);
         return code `((resolved: ${resolveType.name}) => { switch (resolved.${resolveType.discriminantProperty.unsafeCoerce().name}) { ${joinCode(caseBlocks)} } })`;
     }
+    resolvedNamedObjectUnionTypeToPartialNamedObjectUnionTypeConversion({ resolvedNamedObjectUnionType, partialNamedObjectUnionType, variables, }) {
+        invariant(resolvedNamedObjectUnionType.members.length ===
+            partialNamedObjectUnionType.members.length);
+        const caseBlocks = resolvedNamedObjectUnionType.members.map(({ discriminantValues }, memberI) => {
+            return code `${discriminantValues.map((discriminantPropertyValue) => `case "${discriminantPropertyValue}":`).join("\n")} return ${partialNamedObjectUnionType.members[memberI].type.name}.create(${variables.resolvedObjectUnion});`;
+        });
+        caseBlocks.push(code `default: ${variables.resolvedObjectUnion} satisfies never; throw new Error("unrecognized type");`);
+        return code `switch (${variables.resolvedObjectUnion}.${resolvedNamedObjectUnionType.discriminantProperty.unsafeCoerce().name}) { ${joinCode(caseBlocks)} }`;
+    }
 }
 __decorate([
     Memoize()
 ], AbstractLazyObjectType.prototype, "equalsFunction", null);
-__decorate([
-    Memoize()
-], AbstractLazyObjectType.prototype, "hashFunction", null);
 __decorate([
     Memoize()
 ], AbstractLazyObjectType.prototype, "filterFunction", null);
 __decorate([
     Memoize()
-], AbstractLazyObjectType.prototype, "schema", null);
+], AbstractLazyObjectType.prototype, "hashFunction", null);
 __decorate([
     Memoize()
 ], AbstractLazyObjectType.prototype, "schemaType", null);

package/dist/generators/ts/AbstractLiteralType.d.ts

@@ -8,11 +8,7 @@ export declare abstract class AbstractLiteralType extends AbstractTermType<Liter
         languageIn: readonly string[];
     } & ConstructorParameters<typeof AbstractTermType<Literal, Literal>>[0]);
     get constrained(): boolean;
-    protected get schemaObject(): {
-        languageIn: import("ts-poet/build/Node.js").Node[] | undefined;
-        in: Code | undefined;
-        kind: Code;
-    };
+    protected get schemaInitializers(): readonly Code[];
     /**
      * An expression that converts a compile-time RDF/JS Literal into a runtime TypeScript literal.
      *

package/dist/generators/ts/AbstractLiteralType.js

@@ -1,5 +1,5 @@
 import { AbstractTermType } from "./AbstractTermType.js";
-import { code, literalOf } from "./ts-poet-wrapper.js";
+import { arrayOf, code } from "./ts-poet-wrapper.js";
 export class AbstractLiteralType extends AbstractTermType {
     languageIn;
     nodeKinds = nodeKinds;
@@ -10,11 +10,12 @@ export class AbstractLiteralType extends AbstractTermType {
     get constrained() {
         return super.constrained || this.languageIn.length > 0;
     }
-    get schemaObject() {
-        return {
-            ...super.schemaObject,
-            languageIn: this.languageIn.length > 0 ? this.languageIn.map(literalOf) : undefined,
-        };
+    get schemaInitializers() {
+        let initializers = super.schemaInitializers;
+        if (this.languageIn.length > 0) {
+            initializers = initializers.concat(code `languageIn: ${arrayOf(...this.languageIn)}`);
+        }
+        return initializers;
     }
     fromRdfResourceValuesExpressionChain({ variables, }) {
         return {

package/dist/generators/ts/AbstractNumericType.d.ts

@@ -5,7 +5,7 @@ import { type Code } from "./ts-poet-wrapper.js";
  */
 export declare abstract class AbstractNumericType<ValueT extends bigint | number> extends AbstractPrimitiveType<ValueT> {
     readonly hashFunction: Code;
-    abstract readonly kind: "BigIntType" | "FloatType" | "IntType";
+    abstract readonly kind: "BigInt" | "Float" | "Int";
     get filterFunction(): Code;
     get filterType(): Code;
     get name(): Code | string;

package/dist/generators/ts/AbstractPrimitiveType.d.ts

@@ -6,18 +6,14 @@ export declare abstract class AbstractPrimitiveType<ValueT extends bigint | bool
     protected readonly datatype: NamedNode;
     readonly conversionFunction: Maybe<AbstractLiteralType.ConversionFunction>;
     readonly equalsFunction: Code;
-    abstract readonly kind: "BigIntType" | "BooleanType" | "DateTimeType" | "DateType" | "FloatType" | "IntType" | "NumberType" | "StringType";
+    abstract readonly kind: "BigInt" | "Boolean" | "DateTime" | "Date" | "Float" | "Int" | "NumberType" | "String";
     readonly primitiveIn: readonly ValueT[];
     constructor({ datatype, primitiveIn, ...superParameters }: {
         datatype: NamedNode;
         primitiveIn: readonly ValueT[];
     } & ConstructorParameters<typeof AbstractLiteralType>[0]);
     get discriminantProperty(): Maybe<AbstractLiteralType.DiscriminantProperty>;
-    protected get schemaObject(): {
-        in: Code | undefined;
-        languageIn: import("ts-poet/build/Node.js").Node[] | undefined;
-        kind: Code;
-    };
+    protected get schemaInitializers(): readonly Code[];
     fromJsonExpression({ variables, }: Parameters<AbstractLiteralType["fromJsonExpression"]>[0]): Code;
     graphqlResolveExpression({ variables, }: Parameters<AbstractLiteralType["graphqlResolveExpression"]>[0]): Code;
     jsonType(): AbstractLiteralType.JsonType;

package/dist/generators/ts/AbstractPrimitiveType.js

@@ -7,7 +7,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 import { Maybe } from "purify-ts";
 import { Memoize } from "typescript-memoize";
 import { AbstractLiteralType } from "./AbstractLiteralType.js";
-import { code, joinCode } from "./ts-poet-wrapper.js";
+import { arrayOf, code } from "./ts-poet-wrapper.js";
 export class AbstractPrimitiveType extends AbstractLiteralType {
     datatype;
     conversionFunction = Maybe.empty();
@@ -21,13 +21,12 @@ export class AbstractPrimitiveType extends AbstractLiteralType {
     get discriminantProperty() {
         return Maybe.empty();
     }
-    get schemaObject() {
-        return {
-            ...super.schemaObject,
-            in: this.primitiveIn.length > 0
-                ? code `[${joinCode(this.primitiveIn.map((in_) => this.literalExpression(in_)), { on: ", " })}] as const`
-                : undefined,
-        };
+    get schemaInitializers() {
+        let initializers = super.schemaInitializers;
+        if (this.primitiveIn.length > 0) {
+            initializers = initializers.concat(code `in: ${arrayOf(...this.primitiveIn.map((in_) => this.literalExpression(in_)))}`);
+        }
+        return initializers;
     }
     fromJsonExpression({ variables, }) {
         return code `${this.reusables.imports.Either}.of<Error, ${this.name}>(${variables.value})`;

package/dist/generators/ts/AbstractTermType.d.ts

@@ -23,6 +23,7 @@ export declare abstract class AbstractTermType<ConstantTermT extends Literal | N
     readonly mutable: boolean;
     abstract readonly nodeKinds: ReadonlySet<NodeKind>;
     readonly recursive = false;
+    readonly referencesObjectType = false;
     readonly typeofs: readonly Typeof[];
     readonly validationFunction: Maybe<Code>;
     constructor({ hasValues, in_, ...superParameters }: {
@@ -31,11 +32,6 @@ export declare abstract class AbstractTermType<ConstantTermT extends Literal | N
     } & ConstructorParameters<typeof AbstractType>[0]);
     get constrained(): boolean;
     get discriminantProperty(): Maybe<AbstractType.DiscriminantProperty>;
-    get schema(): Code;
-    protected get schemaObject(): {
-        in: Code | undefined;
-        kind: Code;
-    };
     get termTypes(): ReadonlySet<"BlankNode" | "Literal" | "NamedNode">;
     get toRdfResourceValueTypes(): Set<"BlankNode" | "Literal" | "NamedNode">;
     get valueSparqlConstructTriplesFunction(): Code;

package/dist/generators/ts/AbstractTermType.js

@@ -8,7 +8,6 @@ import { NodeKind } from "@shaclmate/shacl-ast";
 import { Maybe } from "purify-ts";
 import { Memoize } from "typescript-memoize";
 import { AbstractType } from "./AbstractType.js";
-import { removeUndefined } from "./removeUndefined.js";
 import { code, joinCode } from "./ts-poet-wrapper.js";
 /**
  * Abstract base class for IdentifierType and LiteralType.
@@ -27,6 +26,7 @@ export class AbstractTermType extends AbstractType {
     in_;
     mutable = false;
     recursive = false;
+    referencesObjectType = false;
     typeofs = ["object"];
     validationFunction = Maybe.empty();
     constructor({ hasValues, in_, ...superParameters }) {
@@ -46,17 +46,6 @@ export class AbstractTermType extends AbstractType {
             type: "string",
         });
     }
-    get schema() {
-        return code `${removeUndefined(this.schemaObject)}`;
-    }
-    get schemaObject() {
-        return {
-            ...super.schemaObject,
-            in: this.in_.length > 0
-                ? code `[${joinCode(this.in_.map((in_) => this.rdfjsTermExpression(in_)), { on: ", " })}] as const`
-                : undefined,
-        };
-    }
     get termTypes() {
         return new Set([...this.nodeKinds].map(NodeKind.toTermType));
     }
@@ -128,9 +117,6 @@ chain(values => ${this.reusables.imports.Either}.sequence([${joinCode(this.hasVa
 __decorate([
     Memoize()
 ], AbstractTermType.prototype, "discriminantProperty", null);
-__decorate([
-    Memoize()
-], AbstractTermType.prototype, "schema", null);
 __decorate([
     Memoize()
 ], AbstractTermType.prototype, "termTypes", null);

package/dist/generators/ts/AbstractType.d.ts

@@ -83,9 +83,9 @@ export declare abstract class AbstractType {
      */
     abstract readonly recursive: boolean;
     /**
-     * TypeScript object describing this type, for runtime use.
+     * Is this type an ObjectType or does it reference an object type?
      */
-    abstract readonly schema: Code;
+    abstract readonly referencesObjectType: boolean;
     /**
      * TypeScript type describing .schema.
      */
@@ -140,12 +140,14 @@ export declare abstract class AbstractType {
         logger: Logger;
         reusables: Reusables;
     });
+    /**
+     * TypeScript object describing this type, for runtime use.
+     */
+    get schema(): Code;
     /**
      * Helper to compose the result of schema along the type hierarchy.
      */
-    protected get schemaObject(): {
-        kind: Code;
-    };
+    protected get schemaInitializers(): readonly Code[];
     /**
      * An expression that converts this type's JSON type to an Either<Error, ThisType>.
      */

package/dist/generators/ts/AbstractType.js

@@ -4,10 +4,9 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-import { invariant } from "ts-invariant";
 import { Memoize } from "typescript-memoize";
 import { rdfjsTermExpression } from "./rdfjsTermExpression.js";
-import { code, literalOf } from "./ts-poet-wrapper.js";
+import { code, joinCode, literalOf } from "./ts-poet-wrapper.js";
 /**
  * Abstract base class all types.
  */
@@ -35,17 +34,23 @@ export class AbstractType {
             snippets: this.reusables.snippets,
         });
     }
+    /**
+     * TypeScript object describing this type, for runtime use.
+     */
+    get schema() {
+        return code `{ ${joinCode(this.schemaInitializers.concat(), { on: ", " })} }`;
+    }
     /**
      * Helper to compose the result of schema along the type hierarchy.
      */
-    get schemaObject() {
-        invariant(this.kind.endsWith("Type"));
-        return {
-            kind: code `${literalOf(this.kind.substring(0, this.kind.length - "Type".length))} as const`,
-        };
+    get schemaInitializers() {
+        return [code `kind: ${literalOf(this.kind)} as const`];
     }
     rdfjsTermExpression;
 }
+__decorate([
+    Memoize()
+], AbstractType.prototype, "schema", null);
 (function (AbstractType) {
     class GraphqlType {
         /**

package/dist/generators/ts/AbstractUnionType.d.ts

@@ -22,7 +22,7 @@ export declare abstract class AbstractUnionType<MemberTypeT extends Type> extend
     get discriminantProperty(): Maybe<AbstractType.DiscriminantProperty>;
     get members(): readonly AbstractUnionType.Member<MemberTypeT>[];
     get mutable(): boolean;
-    get schema(): Code;
+    get referencesObjectType(): boolean;
     get schemaType(): Code;
     get toRdfResourceValueTypes(): AbstractType["toRdfResourceValueTypes"];
     get typeofs(): AbstractType["typeofs"];
@@ -40,32 +40,29 @@ export declare abstract class AbstractUnionType<MemberTypeT extends Type> extend
     protected get inlineToStringFunction(): Code;
     protected get inlineValueSparqlConstructTriplesFunction(): Code;
     protected get inlineValueSparqlWherePatternsFunction(): Code;
-    protected get schemaObject(): {
-        kind: Code;
-        members: Code;
-    };
+    protected get schemaInitializers(): readonly Code[];
     jsonUiSchemaElement(): Maybe<Code>;
     private readonly lazyMembers;
 }
 type Discriminant = ExtrinsicDiscriminant | HybridDiscriminant | IntrinsicDiscriminant | TypeofDiscriminant;
 type ExtrinsicDiscriminant = {
     readonly jsonName: string;
-    readonly kind: "extrinsic";
+    readonly kind: "Extrinsic";
     readonly memberValues: readonly AbstractType.DiscriminantProperty.Value[];
     readonly name: string;
 };
 type HybridDiscriminant = {
     readonly jsonName: string;
-    readonly kind: "hybrid";
+    readonly kind: "Hybrid";
     readonly memberValues: readonly {
-        readonly kind: "extrinsic" | "intrinsic";
+        readonly kind: "Extrinsic" | "Intrinsic";
         readonly ownValues: readonly AbstractType.DiscriminantProperty.Value[];
     }[];
     readonly name: string;
 };
 type IntrinsicDiscriminant = {
     readonly jsonName: string;
-    readonly kind: "intrinsic";
+    readonly kind: "Intrinsic";
     readonly memberValues: readonly {
         readonly descendantValues: readonly AbstractType.DiscriminantProperty.Value[];
         readonly ownValues: readonly AbstractType.DiscriminantProperty.Value[];
@@ -73,7 +70,7 @@ type IntrinsicDiscriminant = {
     readonly name: string;
 };
 type TypeofDiscriminant = {
-    readonly kind: "typeof";
+    readonly kind: "Typeof";
     readonly memberValues: readonly Typeof[];
 };
 export declare namespace Discriminant {