@shaclmate/compiler 4.0.40 → 4.0.42

package/dist/generators/ts/ListType.js

@@ -5,56 +5,74 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
 import { rdf } from "@tpluscode/rdf-ns-builders";
+import { Maybe } from "purify-ts";
 import { Memoize } from "typescript-memoize";
 import { AbstractCollectionType } from "./AbstractCollectionType.js";
-import { code, joinCode } from "./ts-poet-wrapper.js";
+import { code, joinCode, literalOf } from "./ts-poet-wrapper.js";
 export class ListType extends AbstractCollectionType {
     identifierNodeKind;
     toRdfTypes;
+    jsTypes = [
+        { instanceof: "Array", typeof: "object" },
+    ];
     kind = "List";
     constructor({ identifierNodeKind, toRdfTypes, ...superParameters }) {
         super(superParameters);
         this.identifierNodeKind = identifierNodeKind;
         this.toRdfTypes = toRdfTypes;
     }
+    get conversionFunction() {
+        const itemConversionFunction = this.itemType.conversionFunction.orDefault(this.itemConversionFunctionDefault);
+        return Maybe.of({
+            code: code `${this.reusables.snippets.convertToList}(${itemConversionFunction.code}, ${literalOf(!this._mutable)})`,
+            sourceTypes: [
+                {
+                    expression: code `readonly (${joinCode(itemConversionFunction.sourceTypes.map((itemSourceType) => code `${itemSourceType.expression}`), { on: " | " })})[]`,
+                    jsType: { instanceof: "Array", typeof: "object" },
+                },
+            ],
+        });
+    }
+    get fromRdfResourceValuesFunction() {
+        return code `${this._mutable ? this.reusables.snippets.mutableListFromRdfResourceValues : this.reusables.snippets.listFromRdfResourceValues}<${this.itemType.expression}, ${this.itemType.schemaType}>(${this.itemType.fromRdfResourceValuesFunction})`;
+    }
+    get toRdfResourceValueTypes() {
+        return new Set(["BlankNode", "NamedNode"]); // List or rdf:nil
+    }
     get valueSparqlConstructTriplesFunction() {
         return code `${this.reusables.snippets.listSparqlConstructTriples}<${this.itemType.filterType}, ${this.itemType.schemaType}>(${this.itemType.valueSparqlConstructTriplesFunction})`;
     }
     get valueSparqlWherePatternsFunction() {
         return code `${this.reusables.snippets.listSparqlWherePatterns}<${this.itemType.filterType}, ${this.itemType.schemaType}>(${this.itemType.valueSparqlWherePatternsFunction})`;
     }
-    fromRdfResourceValuesExpression({ variables, }) {
-        return joinCode([
-            variables.resourceValues,
-            code `chain(values => values.chainMap(value => value.toList(${{ graph: variables.graph }})))`, // Resource.Values<Resource.Value> to Resource.Values<Resource.Values>
-            code `chain(valueLists =>
-        valueLists.chainMap(
-          valueList => ${this.itemType.fromRdfResourceValuesExpression({
-                variables: {
-                    ...variables,
-                    resourceValues: code `${this.reusables.imports.Right}(${this.reusables.imports.Resource}.Values.fromArray({ focusResource: ${variables.resource}, propertyPath: ${variables.propertyPath}, values: valueList.toArray() }))`,
-                },
-            })}
-      ))`, // Resource.Values<Resource.Values> to Resource.Values<item type arrays>
-            code `map(valueLists => valueLists.map(valueList => valueList.toArray()${this.mutable ? ".concat()" : ""}))`, // Convert inner Resource.Values to arrays
-        ], { on: "." });
+    fromJsonExpression({ variables, }) {
+        return code `${this.reusables.imports.Either}.sequence<Error, ${this.itemType.expression}>(${variables.value}.map(item => (${this.itemType.fromJsonExpression({
+            variables: { value: code `item` },
+        })})))`;
+    }
+    jsonSchema(parameters) {
+        let schema = code `${this.itemType.jsonSchema(parameters)}.array()`;
+        if (!this._mutable) {
+            schema = code `${schema}.readonly()`;
+        }
+        return schema;
     }
     jsonType() {
-        return new AbstractCollectionType.JsonType(code `${!this.mutable ? "readonly " : ""}(${this.itemType.jsonType().name})[]`);
+        return new AbstractCollectionType.JsonType(code `${!this.mutable ? "readonly " : ""}(${this.itemType.jsonType().expression})[]`);
     }
     toRdfResourceValuesExpression({ variables, }) {
         let mintListIdentifierFunction;
         let mintSubListIdentifierFunction;
-        let resourceTypeName;
+        let resourceTypeExpression;
         switch (this.identifierNodeKind) {
             case "BlankNode": {
                 mintListIdentifierFunction =
                     mintSubListIdentifierFunction = code `(() => ${this.reusables.imports.dataFactory}.blankNode())`;
-                resourceTypeName = code `${this.reusables.imports.Resource}<${this.reusables.imports.BlankNode}>`;
+                resourceTypeExpression = code `${this.reusables.imports.Resource}<${this.reusables.imports.BlankNode}>`;
                 break;
             }
             case "IRI": {
-                resourceTypeName = code `${this.reusables.imports.Resource}<${this.reusables.imports.NamedNode}>`;
+                resourceTypeExpression = code `${this.reusables.imports.Resource}<${this.reusables.imports.NamedNode}>`;
                 throw new RangeError("list IRI minting is unsupported");
             }
         }
@@ -81,8 +99,8 @@ export class ListType extends AbstractCollectionType {
     currentSubListResource: null,
     listResource: ${variables.resourceSet}.resource(${mintListIdentifierFunction}()),
   } as {
-    currentSubListResource: ${resourceTypeName} | null;
-    listResource: ${resourceTypeName};
+    currentSubListResource: ${resourceTypeExpression} | null;
+    listResource: ${resourceTypeExpression};
   },
 ).listResource.identifier : ${this.rdfjsTermExpression(rdf.nil)}]`;
     }
@@ -90,6 +108,15 @@ export class ListType extends AbstractCollectionType {
         return code `\`[\${${variables.value}.map(item => (${this.itemType.toStringExpression({ variables: { value: code `item` } })}))}]\``;
     }
 }
+__decorate([
+    Memoize()
+], ListType.prototype, "conversionFunction", null);
+__decorate([
+    Memoize()
+], ListType.prototype, "fromRdfResourceValuesFunction", null);
+__decorate([
+    Memoize()
+], ListType.prototype, "toRdfResourceValueTypes", null);
 __decorate([
     Memoize()
 ], ListType.prototype, "valueSparqlConstructTriplesFunction", null);
@@ -112,6 +139,7 @@ __decorate([
             case "Identifier":
             case "Iri":
             case "Int":
+            case "List":
             case "Literal":
             case "ObjectUnion":
             case "Object":
@@ -120,10 +148,9 @@ __decorate([
             case "Union":
                 return true;
             case "DefaultValue":
-            case "LazyObjectOption":
-            case "LazyObjectSet":
-            case "LazyObject":
-            case "List":
+            case "LazyOption":
+            case "LazySet":
+            case "Lazy":
             case "Option":
             case "Set":
                 return false;

package/dist/generators/ts/LiteralType.d.ts

@@ -3,10 +3,15 @@ import { Maybe } from "purify-ts";
 import { AbstractLiteralType } from "./AbstractLiteralType.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare class LiteralType extends AbstractLiteralType {
-    readonly expression: Code;
+    protected readonly inlineExpression: Code;
     readonly conversionFunction: Maybe<AbstractLiteralType.ConversionFunction>;
     readonly filterFunction: Code;
     readonly filterType: Code;
+    readonly fromRdfResourceValuesFunction: Code;
+    readonly jsTypes: readonly [{
+        readonly instanceof: "Object";
+        readonly typeof: "object";
+    }];
     readonly kind = "Literal";
     readonly schemaType: Code;
     readonly valueSparqlWherePatternsFunction: Code;
@@ -16,7 +21,7 @@ export declare class LiteralType extends AbstractLiteralType {
     graphqlResolveExpression(_parameters: Parameters<AbstractLiteralType["graphqlResolveExpression"]>[0]): Code;
     jsonSchema({ includeDiscriminantProperty, }: Parameters<AbstractLiteralType["jsonSchema"]>[0]): Code;
     jsonType(parameters?: Parameters<AbstractLiteralType["jsonType"]>[0]): AbstractLiteralType.JsonType;
-    literalExpression(literal: Literal): Code;
+    literalValueExpression(literal: Literal): Code;
     toJsonExpression({ includeDiscriminantProperty, variables, }: Parameters<AbstractLiteralType["toJsonExpression"]>[0]): Code;
 }
 //# sourceMappingURL=LiteralType.d.ts.map

package/dist/generators/ts/LiteralType.js

@@ -3,26 +3,30 @@ import { Maybe } from "purify-ts";
 import { AbstractLiteralType } from "./AbstractLiteralType.js";
 import { arrayOf, code } from "./ts-poet-wrapper.js";
 export class LiteralType extends AbstractLiteralType {
-    expression = code `${this.reusables.imports.Literal}`;
+    inlineExpression = code `${this.reusables.imports.Literal}`;
     conversionFunction = Maybe.of({
         code: code `${this.reusables.snippets.convertToLiteral}`,
         sourceTypes: [
             ...["bigint", "boolean", "number", "string"].map((typeof_) => ({
                 expression: code `${typeof_}`,
-                typeof: typeof_,
+                jsType: { typeof: typeof_ },
             })),
             {
                 expression: code `Date`,
-                typeof: "object",
+                jsType: { instanceof: "Date", typeof: "object" },
             },
             {
                 expression: code `${this.reusables.imports.Literal}`,
-                typeof: "object",
+                jsType: { instanceof: "Object", typeof: "object" },
             },
         ],
     });
     filterFunction = code `${this.reusables.snippets.filterLiteral}`;
     filterType = code `${this.reusables.snippets.LiteralFilter}`;
+    fromRdfResourceValuesFunction = code `${this.reusables.snippets.literalFromRdfResourceValues}`;
+    jsTypes = [
+        { instanceof: "Object", typeof: "object" },
+    ];
     kind = "Literal";
     schemaType = code `${this.reusables.snippets.LiteralSchema}`;
     valueSparqlWherePatternsFunction = code `${this.reusables.snippets.literalSparqlWherePatterns}`;
@@ -34,6 +38,9 @@ export class LiteralType extends AbstractLiteralType {
         if (this.in_.length > 0) {
             initializers = initializers.concat(code `in: ${arrayOf(...this.in_.map((in_) => this.rdfjsTermExpression(in_)))}`);
         }
+        if (this.languageIn.length > 0) {
+            initializers = initializers.concat(code `languageIn: ${arrayOf(...this.languageIn)}`);
+        }
         return initializers;
     }
     fromJsonExpression({ variables, }) {
@@ -54,7 +61,7 @@ export class LiteralType extends AbstractLiteralType {
             : "";
         return new AbstractLiteralType.JsonType(code `{ readonly "@language"?: string${discriminantProperty}, readonly "@type"?: string, readonly "@value": string }`);
     }
-    literalExpression(literal) {
+    literalValueExpression(literal) {
         return this.rdfjsTermExpression(literal);
     }
     toJsonExpression({ includeDiscriminantProperty, variables, }) {

package/dist/generators/ts/ObjectType.d.ts

@@ -12,63 +12,66 @@ import type { Type } from "./Type.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare class ObjectType extends AbstractType {
     protected readonly toRdfTypes: readonly NamedNode[];
-    readonly conversionFunction: Maybe<AbstractType.ConversionFunction>;
+    readonly discriminantProperty: Maybe<ObjectType.DiscriminantProperty>;
     readonly extern: boolean;
     readonly fromRdfType: Maybe<NamedNode>;
     readonly graphqlArgs: AbstractType["graphqlArgs"];
     readonly identifierType: BlankNodeType | IdentifierType | IriType;
+    readonly jsTypes: readonly [{
+        readonly instanceof: "Object";
+        readonly typeof: "object";
+    }];
     readonly kind = "Object";
     readonly recursive: boolean;
-    readonly referencesObjectType = true;
     readonly synthetic: boolean;
-    readonly typeofs: "object"[];
     readonly validationFunction: Maybe<Code>;
-    constructor({ extern, fromRdfType, identifierType, lazyAncestorObjectTypes, lazyChildObjectTypes, lazyDescendantObjectTypes, lazyDiscriminantProperty, lazyParentObjectTypes, lazyProperties, recursive, synthetic, toRdfTypes, ...superParameters }: {
+    constructor({ discriminantProperty, extern, fromRdfType, identifierType, lazyProperties, recursive, synthetic, toRdfTypes, ...superParameters }: {
+        discriminantProperty: Maybe<ObjectType.DiscriminantProperty>;
         comment: Maybe<string>;
         extern: boolean;
         fromRdfType: Maybe<NamedNode>;
         identifierType: BlankNodeType | IdentifierType | IriType;
         label: Maybe<string>;
-        lazyAncestorObjectTypes: () => readonly ObjectType[];
-        lazyChildObjectTypes: () => readonly ObjectType[];
-        lazyDiscriminantProperty: (namedObjectType: ObjectType) => ObjectType.DiscriminantProperty;
-        lazyDescendantObjectTypes: () => readonly ObjectType[];
-        lazyParentObjectTypes: () => readonly ObjectType[];
-        lazyProperties: (namedObjectType: ObjectType) => readonly ObjectType.Property[];
+        lazyProperties: (objectType: ObjectType) => readonly ObjectType.Property[];
         recursive: boolean;
         synthetic: boolean;
         toRdfTypes: readonly NamedNode[];
     } & ConstructorParameters<typeof AbstractType>[0]);
-    get _discriminantProperty(): ObjectType.DiscriminantProperty;
-    get ancestorObjectTypes(): readonly ObjectType[];
-    get childObjectTypes(): readonly ObjectType[];
+    get conversionFunction(): Maybe<AbstractType.ConversionFunction>;
     get declaration(): Maybe<Code>;
-    get descendantFromRdfTypeVariables(): readonly Code[];
-    get descendantFromRdfTypes(): readonly NamedNode[];
-    get descendantObjectTypes(): readonly ObjectType[];
-    get discriminantProperty(): Maybe<AbstractType.DiscriminantProperty>;
-    get discriminantValue(): string;
     get equalsFunction(): Code;
     get expression(): Code;
     get filterFunction(): Code;
     get filterType(): Code;
+    get fromRdfResourceValuesFunction(): Code;
     get fromRdfTypeVariable(): Maybe<Code>;
     get graphqlType(): AbstractType.GraphqlType;
     get hashFunction(): Code;
     get identifierTypeAlias(): Code;
     get mutable(): boolean;
     get objectSetMethodNames(): ObjectType.ObjectSetMethodNames;
-    get parentObjectTypes(): readonly ObjectType[];
     get properties(): readonly ObjectType.Property[];
+    get referencesNamedType(): boolean;
     get schema(): Code;
     get schemaType(): Code;
     get toRdfResourceValueTypes(): AbstractType["toRdfResourceValueTypes"];
     get toRdfjsResourceType(): Code;
     get valueSparqlConstructTriplesFunction(): Code;
     get valueSparqlWherePatternsFunction(): Code;
+    protected get constructorParameters(): {
+        hasQuestionToken: boolean;
+        signature: Code;
+        type: {
+            expression: Code;
+        };
+        variable: string;
+    };
+    protected get createFunction(): Code;
     protected get thisVariable(): Code;
+    protected get toJsonFunction(): Code;
+    protected get toStringFunction(): Code;
+    private get inlineExpression();
     fromJsonExpression({ variables, }: Parameters<AbstractType["fromJsonExpression"]>[0]): Code;
-    fromRdfResourceValuesExpression({ variables, }: Parameters<AbstractType["fromRdfResourceValuesExpression"]>[0]): Code;
     graphqlResolveExpression({ variables, }: {
         variables: {
             value: Code;
@@ -80,11 +83,7 @@ export declare class ObjectType extends AbstractType {
     toJsonExpression({ variables, }: Parameters<AbstractType["toJsonExpression"]>[0]): Code;
     toRdfResourceValuesExpression({ variables, }: Parameters<AbstractType["toRdfResourceValuesExpression"]>[0]): Code;
     toStringExpression({ variables, }: Parameters<AbstractType["toStringExpression"]>[0]): Code;
-    private readonly lazyAncestorObjectTypes;
-    private readonly lazyChildObjectTypes;
-    private readonly lazyDescendantObjectTypes;
-    private readonly lazyDiscriminantProperty;
-    private readonly lazyParentObjectTypes;
+    protected toStringRecordExpression({ variables, }: Parameters<AbstractType["toStringExpression"]>[0]): Code;
     private readonly lazyProperties;
 }
 export declare namespace ObjectType {