@shaclmate/compiler 4.0.8 → 4.0.10

package/dist/generators/ts/ListType.js

@@ -22,19 +22,19 @@ export class ListType extends AbstractCollectionType {
         this.identifierMintingStrategy = identifierMintingStrategy.orDefault(identifierNodeKind === "BlankNode" ? "blankNode" : "sha256");
         this.toRdfTypes = toRdfTypes;
     }
-    get sparqlConstructTriplesFunction() {
-        return code `${snippets.listSparqlConstructTriples}<${this.itemType.filterType}, ${this.itemType.schemaType}>(${this.itemType.sparqlConstructTriplesFunction})`;
+    get valueSparqlConstructTriplesFunction() {
+        return code `${snippets.listSparqlConstructTriples}<${this.itemType.filterType}, ${this.itemType.schemaType}>(${this.itemType.valueSparqlConstructTriplesFunction})`;
     }
-    get sparqlWherePatternsFunction() {
-        return code `${snippets.listSparqlWherePatterns}<${this.itemType.filterType}, ${this.itemType.schemaType}>(${this.itemType.sparqlWherePatternsFunction})`;
+    get valueSparqlWherePatternsFunction() {
+        return code `${snippets.listSparqlWherePatterns}<${this.itemType.filterType}, ${this.itemType.schemaType}>(${this.itemType.valueSparqlWherePatternsFunction})`;
     }
-    fromRdfExpression({ variables, }) {
+    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.fromRdfExpression({
+          valueList => ${this.itemType.fromRdfResourceValuesExpression({
                 variables: {
                     ...variables,
                     resourceValues: code `${imports.Right}(${imports.Resource}.Values.fromArray({ focusResource: ${variables.resource}, propertyPath: ${variables.propertyPath}, values: valueList.toArray() }))`,
@@ -45,9 +45,9 @@ export class ListType extends AbstractCollectionType {
         ], { on: "." });
     }
     jsonType() {
-        return new AbstractCollectionType.JsonType(code `readonly (${this.itemType.jsonType().name})[]`);
+        return new AbstractCollectionType.JsonType(code `${!this.mutable ? "readonly " : ""}(${this.itemType.jsonType().name})[]`);
     }
-    toRdfExpression({ variables, }) {
+    toRdfResourceValuesExpression({ variables, }) {
         let listIdentifier;
         let resourceTypeName;
         let subListIdentifier;
@@ -91,7 +91,7 @@ export class ListType extends AbstractCollectionType {
     
     ${joinCode(this.toRdfTypes.map((rdfType) => code `currentSubListResource.add(${rdfjsTermExpression(rdf.type)}, ${imports.dataFactory}.namedNode("${rdfType.value}"), ${variables.graph})`))}
     
-    currentSubListResource.add(${rdfjsTermExpression(rdf.first)}, ${this.itemType.toRdfExpression({ variables: { graph: variables.graph, propertyPath: rdfjsTermExpression(rdf.first), resource: code `currentSubListResource`, resourceSet: variables.resourceSet, value: code `item` } })}, ${variables.graph});
+    currentSubListResource.add(${rdfjsTermExpression(rdf.first)}, ${this.itemType.toRdfResourceValuesExpression({ variables: { graph: variables.graph, propertyPath: rdfjsTermExpression(rdf.first), resource: code `currentSubListResource`, resourceSet: variables.resourceSet, value: code `item` } })}, ${variables.graph});
 
     if (itemIndex + 1 === list.length) {
       currentSubListResource.add(${rdfjsTermExpression(rdf.rest)}, ${rdfjsTermExpression(rdf.nil)}, ${variables.graph});
@@ -111,16 +111,17 @@ export class ListType extends AbstractCollectionType {
 }
 __decorate([
     Memoize()
-], ListType.prototype, "sparqlConstructTriplesFunction", null);
+], ListType.prototype, "valueSparqlConstructTriplesFunction", null);
 __decorate([
     Memoize()
-], ListType.prototype, "sparqlWherePatternsFunction", null);
+], ListType.prototype, "valueSparqlWherePatternsFunction", null);
 __decorate([
     Memoize()
 ], ListType.prototype, "jsonType", null);
 (function (ListType) {
     function isItemType(type) {
         switch (type.kind) {
+            case "AnonymousUnionType":
             case "BigDecimalType":
             case "BigIntType":
             case "BlankNodeType":
@@ -132,11 +133,11 @@ __decorate([
             case "IriType":
             case "IntType":
             case "LiteralType":
-            case "ObjectType":
-            case "ObjectUnionType":
+            case "NamedObjectUnionType":
+            case "NamedUnionType":
+            case "NamedObjectType":
             case "StringType":
             case "TermType":
-            case "UnionType":
                 return true;
             case "DefaultValueType":
             case "LazyObjectOptionType":

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

@@ -6,13 +6,13 @@ export declare class LiteralType extends AbstractLiteralType {
     readonly kind = "LiteralType";
     readonly name: Code;
     readonly schemaType: Code;
-    readonly sparqlWherePatternsFunction: Code;
+    readonly valueSparqlWherePatternsFunction: Code;
     get graphqlType(): AbstractLiteralType.GraphqlType;
     fromJsonExpression({ variables, }: Parameters<AbstractLiteralType["fromJsonExpression"]>[0]): Code;
     graphqlResolveExpression(_parameters: Parameters<AbstractLiteralType["graphqlResolveExpression"]>[0]): Code;
     hashStatements({ depth, variables, }: Parameters<AbstractLiteralType["hashStatements"]>[0]): readonly Code[];
     jsonType(parameters?: Parameters<AbstractLiteralType["jsonType"]>[0]): AbstractLiteralType.JsonType;
-    jsonZodSchema({ includeDiscriminantProperty, }: Parameters<AbstractLiteralType["jsonZodSchema"]>[0]): Code;
+    jsonSchema({ includeDiscriminantProperty, }: Parameters<AbstractLiteralType["jsonSchema"]>[0]): Code;
     toJsonExpression({ includeDiscriminantProperty, variables, }: Parameters<AbstractLiteralType["toJsonExpression"]>[0]): Code;
 }
 //# sourceMappingURL=LiteralType.d.ts.map

package/dist/generators/ts/LiteralType.js

@@ -9,12 +9,12 @@ export class LiteralType extends AbstractLiteralType {
     kind = "LiteralType";
     name = code `${imports.Literal}`;
     schemaType = code `${snippets.LiteralSchema}`;
-    sparqlWherePatternsFunction = code `${snippets.literalSparqlWherePatterns}`;
+    valueSparqlWherePatternsFunction = code `${snippets.literalSparqlWherePatterns}`;
     get graphqlType() {
         throw new Error("not implemented");
     }
     fromJsonExpression({ variables, }) {
-        return code `${imports.dataFactory}.literal(${variables.value}["@value"], ${variables.value}["@language"] !== undefined ? ${variables.value}["@language"] : (${variables.value}["@type"] !== undefined ? ${imports.dataFactory}.namedNode(${variables.value}["@type"]) : undefined))`;
+        return code `${imports.dataFactory}.literal(${variables.value}["@value"], ${variables.value}["@language"] !== undefined ? ${variables.value}["@language"] : (${variables.value}["@type"] !== undefined ? ${imports.dataFactory}.namedNode(${variables.value}["@type"]!) : undefined))`;
     }
     graphqlResolveExpression(_parameters) {
         throw new Error("not implemented");
@@ -32,7 +32,7 @@ export class LiteralType extends AbstractLiteralType {
             : "";
         return new AbstractLiteralType.JsonType(code `{ readonly "@language"?: string${discriminantProperty}, readonly "@type"?: string, readonly "@value": string }`);
     }
-    jsonZodSchema({ includeDiscriminantProperty, }) {
+    jsonSchema({ includeDiscriminantProperty, }) {
         const discriminantProperty = includeDiscriminantProperty
             ? code `, termType: ${imports.z}.literal("Literal")`
             : "";

package/dist/generators/ts/NamedObjectType.d.ts

@@ -0,0 +1,126 @@
+import type { NamedNode } from "@rdfjs/types";
+import { Maybe, NonEmptyList } from "purify-ts";
+import type { TsFeature } from "../../enums/TsFeature.js";
+import type { TsObjectDeclarationType } from "../../enums/TsObjectDeclarationType.js";
+import { DiscriminantProperty as _DiscriminantProperty } from "./_NamedObjectType/DiscriminantProperty.js";
+import { IdentifierPrefixProperty as _IdentifierPrefixProperty } from "./_NamedObjectType/IdentifierPrefixProperty.js";
+import { IdentifierProperty as _IdentifierProperty } from "./_NamedObjectType/IdentifierProperty.js";
+import type { Property as _Property } from "./_NamedObjectType/Property.js";
+import { ShaclProperty as _ShaclProperty } from "./_NamedObjectType/ShaclProperty.js";
+import { AbstractType } from "./AbstractType.js";
+import type { BlankNodeType } from "./BlankNodeType.js";
+import type { IdentifierType } from "./IdentifierType.js";
+import type { IriType } from "./IriType.js";
+import type { Type } from "./Type.js";
+import { type Code } from "./ts-poet-wrapper.js";
+export declare class NamedObjectType extends AbstractType {
+    private readonly imports;
+    protected readonly toRdfTypes: readonly NamedNode[];
+    readonly abstract: boolean;
+    readonly declarationType: TsObjectDeclarationType;
+    readonly extern: boolean;
+    readonly features: ReadonlySet<TsFeature>;
+    readonly fromRdfType: Maybe<NamedNode>;
+    readonly graphqlArgs: AbstractType["graphqlArgs"];
+    readonly identifierType: BlankNodeType | IdentifierType | IriType;
+    readonly kind = "NamedObjectType";
+    readonly name: string;
+    readonly recursive: boolean;
+    readonly staticModuleName: string;
+    readonly synthetic: boolean;
+    readonly typeofs: NonEmptyList<"object">;
+    constructor({ abstract, declarationType, extern, features, fromRdfType, identifierType, imports, lazyAncestorObjectTypes, lazyChildObjectTypes, lazyDescendantObjectTypes, lazyDiscriminantProperty, lazyIdentifierProperty, lazyParentObjectTypes, lazyProperties, name, recursive, staticModuleName, synthetic, toRdfTypes, ...superParameters }: {
+        abstract: boolean;
+        comment: Maybe<string>;
+        declarationType: TsObjectDeclarationType;
+        extern: boolean;
+        features: ReadonlySet<TsFeature>;
+        fromRdfType: Maybe<NamedNode>;
+        identifierType: BlankNodeType | IdentifierType | IriType;
+        imports: readonly string[];
+        label: Maybe<string>;
+        lazyAncestorObjectTypes: () => readonly NamedObjectType[];
+        lazyChildObjectTypes: () => readonly NamedObjectType[];
+        lazyDiscriminantProperty: (namedObjectType: NamedObjectType) => NamedObjectType.DiscriminantProperty;
+        lazyIdentifierProperty: (namedObjectType: NamedObjectType) => NamedObjectType.IdentifierProperty;
+        lazyDescendantObjectTypes: () => readonly NamedObjectType[];
+        lazyParentObjectTypes: () => readonly NamedObjectType[];
+        lazyProperties: (namedObjectType: NamedObjectType) => readonly NamedObjectType.Property[];
+        name: string;
+        recursive: boolean;
+        staticModuleName: string;
+        synthetic: boolean;
+        toRdfTypes: readonly NamedNode[];
+    } & ConstructorParameters<typeof AbstractType>[0]);
+    get _discriminantProperty(): NamedObjectType.DiscriminantProperty;
+    get ancestorObjectTypes(): readonly NamedObjectType[];
+    get childObjectTypes(): readonly NamedObjectType[];
+    get conversions(): readonly AbstractType.Conversion[];
+    get declaration(): Maybe<Code>;
+    get descendantFromRdfTypeVariables(): readonly Code[];
+    get descendantFromRdfTypes(): readonly NamedNode[];
+    get descendantObjectTypes(): readonly NamedObjectType[];
+    get discriminantProperty(): Maybe<AbstractType.DiscriminantProperty>;
+    get discriminantValue(): string;
+    get equalsFunction(): Code;
+    get filterFunction(): Code;
+    get filterType(): Code;
+    get fromRdfTypeVariable(): Maybe<Code>;
+    get graphqlType(): AbstractType.GraphqlType;
+    get identifierProperty(): NamedObjectType.IdentifierProperty;
+    get identifierTypeAlias(): Code;
+    get mutable(): boolean;
+    get objectSetMethodNames(): NamedObjectType.ObjectSetMethodNames;
+    get ownProperties(): readonly NamedObjectType.Property[];
+    get ownShaclProperties(): readonly NamedObjectType.ShaclProperty<Type>[];
+    get parentObjectTypes(): readonly NamedObjectType[];
+    get properties(): readonly NamedObjectType.Property[];
+    get schema(): Code;
+    get schemaType(): Code;
+    get toRdfjsResourceType(): Code;
+    get valueSparqlConstructTriplesFunction(): Code;
+    get valueSparqlWherePatternsFunction(): Code;
+    protected get thisVariable(): Code;
+    fromJsonExpression({ variables, }: Parameters<AbstractType["fromJsonExpression"]>[0]): Code;
+    fromRdfResourceValuesExpression({ variables, }: Parameters<AbstractType["fromRdfResourceValuesExpression"]>[0]): Code;
+    graphqlResolveExpression({ variables, }: {
+        variables: {
+            value: Code;
+        };
+    }): Code;
+    hashStatements({ variables, }: Parameters<AbstractType["hashStatements"]>[0]): readonly Code[];
+    jsonSchema({ context, }: Parameters<AbstractType["jsonSchema"]>[0]): Code;
+    jsonType(): AbstractType.JsonType;
+    jsonUiSchemaElement({ variables, }: Parameters<AbstractType["jsonUiSchemaElement"]>[0]): Maybe<Code>;
+    newExpression({ parameters }: {
+        parameters: Code;
+    }): Code;
+    toJsonExpression({ variables, }: Parameters<AbstractType["toJsonExpression"]>[0]): Code;
+    toRdfResourceValuesExpression({ variables, }: Parameters<AbstractType["toRdfResourceValuesExpression"]>[0]): Code;
+    protected ensureAtMostOneSuperObjectType(): void;
+    private readonly lazyAncestorObjectTypes;
+    private readonly lazyChildObjectTypes;
+    private readonly lazyDescendantObjectTypes;
+    private readonly lazyDiscriminantProperty;
+    private readonly lazyIdentifierProperty;
+    private readonly lazyParentObjectTypes;
+    private readonly lazyProperties;
+}
+export declare namespace NamedObjectType {
+    const IdentifierPrefixProperty: typeof _IdentifierPrefixProperty;
+    type IdentifierPrefixProperty = _IdentifierPrefixProperty;
+    const IdentifierProperty: typeof _IdentifierProperty;
+    type IdentifierProperty = _IdentifierProperty;
+    type ObjectSetMethodNames = {
+        readonly object: string;
+        readonly objectCount: string;
+        readonly objectIdentifiers: string;
+        readonly objects: string;
+    };
+    type Property = _Property;
+    const ShaclProperty: typeof _ShaclProperty;
+    type ShaclProperty<TypeT extends Type> = _ShaclProperty<TypeT>;
+    const DiscriminantProperty: typeof _DiscriminantProperty;
+    type DiscriminantProperty = _DiscriminantProperty;
+}
+//# sourceMappingURL=NamedObjectType.d.ts.map