@shaclmate/compiler 4.0.33 → 4.0.35

package/dist/generators/ts/OptionType.d.ts

@@ -1,19 +1,21 @@
-import { Maybe, NonEmptyList } from "purify-ts";
+import { Maybe } from "purify-ts";
 import { AbstractContainerType } from "./AbstractContainerType.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare class OptionType<ItemTypeT extends OptionType.ItemType> extends AbstractContainerType<ItemTypeT> {
     readonly discriminantProperty: Maybe<AbstractContainerType.DiscriminantProperty>;
     readonly graphqlArgs: AbstractContainerType<ItemTypeT>["graphqlArgs"];
     readonly kind = "OptionType";
-    readonly typeofs: NonEmptyList<"object">;
-    get conversions(): readonly AbstractContainerType.Conversion[];
+    readonly typeofs: "object"[];
+    get conversionFunction(): Maybe<AbstractContainerType.ConversionFunction>;
     get equalsFunction(): Code;
     get filterFunction(): Code;
     get filterType(): Code;
     get graphqlType(): AbstractContainerType.GraphqlType;
+    get hashFunction(): Code;
     get mutable(): boolean;
     get name(): Code;
     get schemaType(): Code;
+    get validationFunction(): Maybe<Code>;
     get valueSparqlConstructTriplesFunction(): Code;
     get valueSparqlWherePatternsFunction(): Code;
     protected get schemaObject(): {
@@ -23,10 +25,9 @@ export declare class OptionType<ItemTypeT extends OptionType.ItemType> extends A
     fromJsonExpression({ variables, }: Parameters<AbstractContainerType<ItemTypeT>["fromJsonExpression"]>[0]): Code;
     fromRdfResourceValuesExpression(parameters: Parameters<AbstractContainerType<ItemTypeT>["fromRdfResourceValuesExpression"]>[0]): Code;
     graphqlResolveExpression(parameters: Parameters<AbstractContainerType<ItemTypeT>["graphqlResolveExpression"]>[0]): Code;
-    hashStatements({ depth, variables, }: Parameters<AbstractContainerType<ItemTypeT>["hashStatements"]>[0]): readonly Code[];
+    jsonSchema(parameters: Parameters<AbstractContainerType<ItemTypeT>["jsonSchema"]>[0]): Code;
     jsonType(parameters?: Parameters<AbstractContainerType<ItemTypeT>["jsonType"]>[0]): AbstractContainerType.JsonType;
     jsonUiSchemaElement(parameters: Parameters<AbstractContainerType<ItemTypeT>["jsonUiSchemaElement"]>[0]): Maybe<Code>;
-    jsonSchema(parameters: Parameters<AbstractContainerType<ItemTypeT>["jsonSchema"]>[0]): Code;
     toJsonExpression({ variables, }: Parameters<AbstractContainerType<ItemTypeT>["toJsonExpression"]>[0]): Code;
     toRdfResourceValuesExpression({ variables, }: Parameters<AbstractContainerType<ItemTypeT>["toRdfResourceValuesExpression"]>[0]): Code;
     toStringExpression({ variables, }: Parameters<AbstractContainerType<ItemTypeT>["toStringExpression"]>[0]): Code;

package/dist/generators/ts/OptionType.js

@@ -4,45 +4,29 @@ 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 { Maybe, NonEmptyList } from "purify-ts";
+import { Maybe } from "purify-ts";
 import { invariant } from "ts-invariant";
 import { Memoize } from "typescript-memoize";
-import { AbstractCollectionType } from "./AbstractCollectionType.js";
 import { AbstractContainerType } from "./AbstractContainerType.js";
 import { codeEquals } from "./codeEquals.js";
-import { code, joinCode, literalOf } from "./ts-poet-wrapper.js";
+import { code, literalOf } from "./ts-poet-wrapper.js";
 export class OptionType extends AbstractContainerType {
     discriminantProperty = Maybe.empty();
     graphqlArgs = Maybe.empty();
     kind = "OptionType";
-    typeofs = NonEmptyList(["object"]);
-    get conversions() {
-        const conversions = [];
-        conversions.push({
-            conversionExpression: (value) => value,
-            sourceTypeCheckExpression: (value) => code `${this.reusables.imports.Maybe}.isMaybe(${value})`,
-            sourceTypeName: this.name,
-            sourceTypeof: "object",
+    typeofs = ["object"];
+    get conversionFunction() {
+        const itemConversionFunction = this.itemType.conversionFunction.orDefault(this.itemConversionFunctionDefault);
+        return Maybe.of({
+            code: code `${this.reusables.snippets.convertToMaybe}(${itemConversionFunction.code})`,
+            sourceTypes: itemConversionFunction.sourceTypes.concat({
+                name: this.name,
+                typeof: "object",
+            }, {
+                name: code `undefined`,
+                typeof: "undefined",
+            }),
         });
-        for (const itemTypeConversion of this.itemType.conversions) {
-            conversions.push({
-                ...itemTypeConversion,
-                conversionExpression: (value) => code `${this.reusables.imports.Maybe}.of(${itemTypeConversion.conversionExpression(value)})`,
-            });
-        }
-        // Unless itemType is a list, it should only have a conversion from undefined if it has a
-        // defaultValue. Per the CST->AST transformation logic, a type with a defaultValue
-        // should never be wrapped in an OptionType.
-        invariant(!conversions.some((conversion) => conversion.sourceTypeof === "undefined") || this.itemType instanceof AbstractCollectionType);
-        if (!conversions.some((conversion) => conversion.sourceTypeof === "undefined")) {
-            conversions.push({
-                conversionExpression: () => code `${this.reusables.imports.Maybe}.empty()`,
-                sourceTypeCheckExpression: (value) => code `${value} === undefined`,
-                sourceTypeName: code `undefined`,
-                sourceTypeof: "undefined",
-            });
-        }
-        return conversions;
     }
     get equalsFunction() {
         return code `((left, right) => ${this.reusables.snippets.maybeEquals}(left, right, ${this.itemType.equalsFunction}))`;
@@ -59,6 +43,9 @@ export class OptionType extends AbstractContainerType {
             nullable: true,
         });
     }
+    get hashFunction() {
+        return code `${this.reusables.snippets.hashMaybe}(${this.itemType.hashFunction})`;
+    }
     get mutable() {
         return this.itemType.mutable;
     }
@@ -68,6 +55,9 @@ export class OptionType extends AbstractContainerType {
     get schemaType() {
         return code `${this.reusables.snippets.MaybeSchema}<${this.itemType.schemaType}>`;
     }
+    get validationFunction() {
+        return Maybe.of(code `${this.reusables.snippets.validateMaybe}(${this.itemType.validationFunction.orDefault(this.itemValidationFunctionDefault)})`);
+    }
     get valueSparqlConstructTriplesFunction() {
         return code `${this.reusables.snippets.maybeSparqlConstructTriples}<${this.itemType.filterType}, ${this.itemType.schemaType}>(${this.itemType.valueSparqlConstructTriplesFunction})`;
     }
@@ -82,13 +72,10 @@ export class OptionType extends AbstractContainerType {
     }
     fromJsonExpression({ variables, }) {
         const expression = code `${this.reusables.imports.Maybe}.fromNullable(${variables.value})`;
-        const valueVariable = code `item`;
         const itemFromJsonExpression = this.itemType.fromJsonExpression({
-            variables: { value: valueVariable },
+            variables: { value: code `item` },
         });
-        return codeEquals(itemFromJsonExpression, valueVariable)
-            ? expression
-            : code `${expression}.map(item => (${itemFromJsonExpression}))`;
+        return code `${expression}.map(item => (${itemFromJsonExpression}).map(${this.reusables.imports.Maybe}.of)).orDefault(${this.reusables.imports.Either}.of(${this.reusables.imports.Maybe}.empty()))`;
     }
     fromRdfResourceValuesExpression(parameters) {
         const { variables } = parameters;
@@ -97,18 +84,8 @@ export class OptionType extends AbstractContainerType {
     graphqlResolveExpression(parameters) {
         return code `${this.itemType.graphqlResolveExpression(parameters)}.extractNullable()`;
     }
-    hashStatements({ depth, variables, }) {
-        return [
-            code `${variables.value}.ifJust((value${depth}) => { ${joinCode(this.itemType
-                .hashStatements({
-                depth: depth + 1,
-                variables: {
-                    hasher: variables.hasher,
-                    value: code `value${depth}`,
-                },
-            })
-                .concat())} });`,
-        ];
+    jsonSchema(parameters) {
+        return code `${this.itemType.jsonSchema(parameters)}.optional()`;
     }
     jsonType(parameters) {
         const itemTypeJsonType = this.itemType.jsonType(parameters);
@@ -120,9 +97,6 @@ export class OptionType extends AbstractContainerType {
     jsonUiSchemaElement(parameters) {
         return this.itemType.jsonUiSchemaElement(parameters);
     }
-    jsonSchema(parameters) {
-        return code `${this.itemType.jsonSchema(parameters)}.optional()`;
-    }
     toJsonExpression({ variables, }) {
         return code `${variables.value}.map(item => (${this.itemType.toJsonExpression({ variables: { value: code `item` } })})).extract()`;
     }
@@ -142,7 +116,7 @@ export class OptionType extends AbstractContainerType {
 }
 __decorate([
     Memoize()
-], OptionType.prototype, "conversions", null);
+], OptionType.prototype, "conversionFunction", null);
 __decorate([
     Memoize()
 ], OptionType.prototype, "equalsFunction", null);
@@ -155,12 +129,18 @@ __decorate([
 __decorate([
     Memoize()
 ], OptionType.prototype, "graphqlType", null);
+__decorate([
+    Memoize()
+], OptionType.prototype, "hashFunction", null);
 __decorate([
     Memoize()
 ], OptionType.prototype, "name", null);
 __decorate([
     Memoize()
 ], OptionType.prototype, "schemaType", null);
+__decorate([
+    Memoize()
+], OptionType.prototype, "validationFunction", null);
 __decorate([
     Memoize()
 ], OptionType.prototype, "valueSparqlConstructTriplesFunction", null);

package/dist/generators/ts/Reusables.d.ts

@@ -1,10 +1,12 @@
 import type { Logger } from "ts-log";
 import { Imports } from "./Imports.js";
 import { Snippets } from "./Snippets.js";
+import type { TsGenerator } from "./TsGenerator.js";
 export declare class Reusables {
     readonly imports: Imports;
     readonly snippets: Snippets;
-    constructor({ logger }: {
+    constructor({ configuration, logger, }: {
+        configuration: TsGenerator.Configuration;
         logger: Logger;
     });
 }

package/dist/generators/ts/Reusables.js

@@ -3,9 +3,10 @@ import { Snippets } from "./Snippets.js";
 export class Reusables {
     imports;
     snippets;
-    constructor({ logger }) {
+    constructor({ configuration, logger, }) {
         this.imports = new Imports();
         this.snippets = new Snippets({
+            configuration,
             imports: this.imports,
             logger,
         });

package/dist/generators/ts/SetType.d.ts

@@ -3,7 +3,6 @@ import { type Code } from "./ts-poet-wrapper.js";
 export declare class SetType<ItemTypeT extends SetType.ItemType> extends AbstractCollectionType<ItemTypeT> {
     readonly graphqlArgs: AbstractCollectionType<ItemTypeT>["graphqlArgs"];
     readonly kind = "SetType";
-    get conversions(): readonly AbstractCollectionType.Conversion[];
     get valueSparqlConstructTriplesFunction(): Code;
     get valueSparqlWherePatternsFunction(): Code;
     fromRdfResourceValuesExpression(parameters: Parameters<AbstractCollectionType<ItemTypeT>["fromRdfResourceValuesExpression"]>[0]): Code;

package/dist/generators/ts/SetType.js

@@ -11,18 +11,6 @@ import { code, joinCode } from "./ts-poet-wrapper.js";
 export class SetType extends AbstractCollectionType {
     graphqlArgs = Maybe.empty();
     kind = "SetType";
-    get conversions() {
-        const conversions = [];
-        if (this.minCount === 0n) {
-            conversions.push({
-                conversionExpression: () => code `[]`,
-                sourceTypeCheckExpression: (value) => code `${value} === undefined`,
-                sourceTypeName: code `undefined`,
-                sourceTypeof: "undefined",
-            });
-        }
-        return conversions.concat(super.conversions);
-    }
     get valueSparqlConstructTriplesFunction() {
         return code `${this.reusables.snippets.setSparqlConstructTriples}<${this.itemType.filterType}, ${this.itemType.schemaType}>(${this.itemType.valueSparqlConstructTriplesFunction})`;
     }
@@ -31,17 +19,11 @@ export class SetType extends AbstractCollectionType {
     }
     fromRdfResourceValuesExpression(parameters) {
         const { variables } = parameters;
-        const chain = [
+        return joinCode([
             this.itemType.fromRdfResourceValuesExpression(parameters),
-        ];
-        if (this.minCount === 0n || this._mutable) {
-            chain.push(code `map(values => values.toArray()${this._mutable ? ".concat()" : ""})`);
-        }
-        else {
-            chain.push(code `chain(values => ${this.reusables.imports.NonEmptyList}.fromArray(values.toArray()).toEither(new Error(\`\${${variables.resource}.identifier} is an empty set\`)))`);
-        }
-        chain.push(code `map(valuesArray => ${this.reusables.imports.Resource}.Values.fromValue({ focusResource: ${variables.resource}, propertyPath: ${variables.propertyPath}, value: valuesArray }))`);
-        return joinCode(chain, { on: "." });
+            code `map(values => values.toArray()${this._mutable ? ".concat()" : ""})`,
+            code `map(valuesArray => ${this.reusables.imports.Resource}.Values.fromValue({ focusResource: ${variables.resource}, propertyPath: ${variables.propertyPath}, value: valuesArray }))`,
+        ], { on: "." });
     }
     jsonType() {
         const name = code `${!this.mutable ? "readonly " : ""}(${this.itemType.jsonType().name})[]`;

package/dist/generators/ts/SnippetFactory.d.ts

@@ -3,8 +3,10 @@ import type { Logger } from "ts-log";
 import type { Imports } from "./Imports.js";
 import type { Snippet } from "./Snippet.js";
 import type { Snippets } from "./Snippets.js";
+import type { TsGenerator } from "./TsGenerator.js";
 import type { Code } from "./ts-poet-wrapper.js";
 export type SnippetFactory = (parameters: {
+    configuration: TsGenerator.Configuration;
     imports: Imports;
     logger: Logger;
     rdfjsTermExpression: (rdfjsTerm: Omit<BlankNode, "equals"> | Omit<Literal, "equals"> | Omit<NamedNode, "equals"> | Omit<Variable, "equals">) => Code;

package/dist/generators/ts/Snippets.d.ts

@@ -1,11 +1,14 @@
 import type { Logger } from "ts-log";
 import type { Imports } from "./Imports.js";
 import type { Snippet } from "./Snippet.js";
+import type { TsGenerator } from "./TsGenerator.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare class Snippets {
-    protected readonly imports: Imports;
-    protected readonly logger: Logger;
-    constructor({ imports, logger }: {
+    private readonly configuration;
+    private readonly imports;
+    private readonly logger;
+    constructor({ configuration, imports, logger, }: {
+        configuration: TsGenerator.Configuration;
         imports: Imports;
         logger: Logger;
     });
@@ -15,6 +18,7 @@ export declare class Snippets {
     get BooleanSchema(): Snippet;
     get CollectionFilter(): Snippet;
     get CollectionSchema(): Snippet;
+    get ConversionFunction(): Snippet;
     get DateFilter(): Snippet;
     get DateSchema(): Snippet;
     get DefaultValueSchema(): Snippet;
@@ -23,6 +27,7 @@ export declare class Snippets {
     get FocusSparqlWherePatternsFunction(): Snippet;
     get FromRdfResourceFunction(): Snippet;
     get FromRdfResourceValuesFunction(): Snippet;
+    get HashFunction(): Snippet;
     get Hasher(): Snippet;
     get IdentifierFilter(): Snippet;
     get IdentifierSchema(): Snippet;
@@ -51,6 +56,7 @@ export declare class Snippets {
     get ToRdfResourceFunction(): Snippet;
     get ToRdfResourceValuesFunction(): Snippet;
     get UnwrapR(): Snippet;
+    get ValidationFunction(): Snippet;
     get ValueSparqlConstructTriplesFunction(): Snippet;
     get ValueSparqlWherePatternsFunction(): Snippet;
     get _FromRdfResourceFunction(): Snippet;
@@ -63,6 +69,19 @@ export declare class Snippets {
     get booleanEquals(): Snippet;
     get booleanSparqlWherePatterns(): Snippet;
     get compactRecord(): Snippet;
+    get convertToArray(): Snippet;
+    get convertToBlankNode(): Snippet;
+    get convertToBlankNodeIdentifierProperty(): Snippet;
+    get convertToIdentifier(): Snippet;
+    get convertToIdentifierProperty(): Snippet;
+    get convertToIri(): Snippet;
+    get convertToIriIdentifierProperty(): Snippet;
+    get convertToLazyObject(): Snippet;
+    get convertToLazyObjectOption(): Snippet;
+    get convertToLazyObjectSet(): Snippet;
+    get convertToLiteral(): Snippet;
+    get convertToMaybe(): Snippet;
+    get convertWithDefaultValue(): Snippet;
     get dateEquals(): Snippet;
     get dateSparqlWherePatterns(): Snippet;
     get decodeBigDecimalLiteral(): Snippet;
@@ -82,14 +101,20 @@ export declare class Snippets {
     get filterTerm(): Snippet;
     get fromRdfLanguageIn(): Snippet;
     get fromRdfPreferredLanguages(): Snippet;
+    get hashArray(): Snippet;
+    get hashBigDecimal(): Snippet;
+    get hashBoolean(): Snippet;
+    get hashDate(): Snippet;
+    get hashDateTime(): Snippet;
+    get hashMaybe(): Snippet;
+    get hashNumeric(): Snippet;
+    get hashString(): Snippet;
+    get hashTerm(): Snippet;
     get identifierSparqlWherePatterns(): Snippet;
+    get identityConversionFunction(): Snippet;
+    get identityValidationFunction(): Snippet;
     get ifUsed(): Code[];
     get iriSparqlWherePatterns(): Snippet;
-    get isReadonlyBigIntArray(): Snippet;
-    get isReadonlyBooleanArray(): Snippet;
-    get isReadonlyNumberArray(): Snippet;
-    get isReadonlyObjectArray(): Snippet;
-    get isReadonlyStringArray(): Snippet;
     get liftSparqlPatterns(): Snippet;
     get listSparqlConstructTriples(): Snippet;
     get listSparqlWherePatterns(): Snippet;
@@ -119,6 +144,9 @@ export declare class Snippets {
     get termFilterSparqlPatterns(): Snippet;
     get termSchemaSparqlPatterns(): Snippet;
     get termSparqlWherePatterns(): Snippet;
+    get toIsoDateString(): Snippet;
+    get validateArray(): Snippet;
+    get validateMaybe(): Snippet;
     get wrap_FromRdfResourceFunction(): Snippet;
     get wrap_ToRdfResourceFunction(): Snippet;
     protected get snippets(): Snippets;