@shaclmate/compiler 4.0.23 → 4.0.25

package/dist/generators/ts/_NamedObjectType/ShaclProperty.js

@@ -47,35 +47,22 @@ export class ShaclProperty extends AbstractProperty {
     }
     get declaration() {
         const lhs = [];
-        if (this.namedObjectType.declarationType === "class" &&
-            this.visibility !== "public") {
-            lhs.push(code `${this.visibility}`);
-        }
         if (!this.mutable) {
             lhs.push(code `readonly`);
         }
         lhs.push(code `${this.name}`);
-        return Maybe.of(code `${this.comment
+        return code `${this.comment
             .alt(this.description)
             .alt(this.label)
             .map(tsComment)
-            .orDefault("")}${joinCode(lhs, { on: " " })}: ${this.type.name};`);
-    }
-    get equalsFunction() {
-        return Maybe.of(this.type.equalsFunction);
+            .orDefault("")}${joinCode(lhs, { on: " " })}: ${this.type.name};`;
     }
     get filterProperty() {
-        if (this.visibility !== "public") {
-            return Maybe.empty();
-        }
         return Maybe.of({
             name: this.name,
             type: this.type.filterType,
         });
     }
-    get getAccessorDeclaration() {
-        return Maybe.empty();
-    }
     get graphqlField() {
         const args = this.type.graphqlArgs;
         const argsVariable = args.isJust() ? code `args` : code `_args`;
@@ -92,7 +79,7 @@ export class ShaclProperty extends AbstractProperty {
             context: "property",
         });
         const meta = {
-            id: this.name,
+        // id: `${this.namedObjectType.name}-${this.name}`, // id's must be unique
         };
         this.comment.alt(this.description).ifJust((description) => {
             meta["description"] = description;
@@ -130,28 +117,13 @@ export class ShaclProperty extends AbstractProperty {
     constructorStatements({ variables, }) {
         const typeConversions = this.type.conversions;
         if (typeConversions.length === 1) {
-            switch (this.namedObjectType.declarationType) {
-                case "class":
-                    return [code `this.${this.name} = ${variables.parameter};`];
-                case "interface":
-                    return [code `const ${this.name} = ${variables.parameter};`];
-            }
-        }
-        let lhs;
-        const statements = [];
-        switch (this.namedObjectType.declarationType) {
-            case "class":
-                lhs = `this.${this.name}`;
-                break;
-            case "interface":
-                lhs = `${this.name}`;
-                statements.push(code `let ${this.name}: ${this.type.name};`);
-                break;
+            return [code `const ${this.name} = ${variables.parameter};`];
         }
+        const statements = [code `let ${this.name}: ${this.type.name};`];
         statements.push(joinCode(typeConversions
-            .map((conversion) => code `if (${conversion.sourceTypeCheckExpression(variables.parameter)}) { ${lhs} = ${conversion.conversionExpression(variables.parameter)}; }`)
+            .map((conversion) => code `if (${conversion.sourceTypeCheckExpression(variables.parameter)}) { ${this.name} = ${conversion.conversionExpression(variables.parameter)}; }`)
             // We shouldn't need this else, since the parameter now has the never type, but have to add it to appease the TypeScript compiler
-            .concat(code `{ ${lhs} = (${variables.parameter}) satisfies never; }`), { on: " else " }));
+            .concat(code `{ ${this.name} = (${variables.parameter}) satisfies never; }`), { on: " else " }));
         return statements;
     }
     fromJsonStatements({ variables, }) {
@@ -171,7 +143,7 @@ export class ShaclProperty extends AbstractProperty {
                 variables: {
                     ...variables,
                     ignoreRdfType: true,
-                    propertyPath: code `${this.namedObjectType.staticModuleName}.${syntheticNamePrefix}schema.properties.${this.name}.path`,
+                    propertyPath: code `${this.namedObjectType.name}.${syntheticNamePrefix}schema.properties.${this.name}.path`,
                     resourceValues: code `resourceValues`,
                 },
             })})`,
@@ -264,9 +236,6 @@ __decorate([
 __decorate([
     Memoize()
 ], ShaclProperty.prototype, "declaration", null);
-__decorate([
-    Memoize()
-], ShaclProperty.prototype, "equalsFunction", null);
 __decorate([
     Memoize()
 ], ShaclProperty.prototype, "filterProperty", null);

package/dist/generators/ts/_snippets/snippets_LazyObject.js

@@ -5,7 +5,7 @@ export const snippets_LazyObject = conditionalOutput(`${syntheticNamePrefix}Lazy
 /**
  * Type of lazy properties that return a single required object. This is a class instead of an interface so it can be instanceof'd elsewhere.
  */
-export class ${syntheticNamePrefix}LazyObject<ObjectIdentifierT extends ${imports.BlankNode} | ${imports.NamedNode}, PartialObjectT extends { ${syntheticNamePrefix}identifier: ObjectIdentifierT }, ResolvedObjectT extends { ${syntheticNamePrefix}identifier: ObjectIdentifierT }> {
+export class ${syntheticNamePrefix}LazyObject<ObjectIdentifierT extends ${imports.BlankNode} | ${imports.NamedNode}, PartialObjectT extends { ${syntheticNamePrefix}identifier: () => ObjectIdentifierT }, ResolvedObjectT extends { ${syntheticNamePrefix}identifier: () => ObjectIdentifierT }> {
   readonly partial: PartialObjectT;
   private readonly resolver: (identifier: ObjectIdentifierT, options?: { preferredLanguages?: readonly string[] }) => Promise<${imports.Either}<Error, ResolvedObjectT>>;
 
@@ -18,7 +18,7 @@ export class ${syntheticNamePrefix}LazyObject<ObjectIdentifierT extends ${import
   }
 
   resolve(options?: { preferredLanguages?: readonly string[] }): Promise<${imports.Either}<Error, ResolvedObjectT>> {
-    return this.resolver(this.partial.${syntheticNamePrefix}identifier, options);
+    return this.resolver(this.partial.${syntheticNamePrefix}identifier(), options);
   }
 }`);
 //# sourceMappingURL=snippets_LazyObject.js.map

package/dist/generators/ts/_snippets/snippets_LazyObjectOption.js

@@ -5,7 +5,7 @@ export const snippets_LazyObjectOption = conditionalOutput(`${syntheticNamePrefi
 /**
  * Type of lazy properties that return a single optional object. This is a class instead of an interface so it can be instanceof'd elsewhere.
  */
-export class ${syntheticNamePrefix}LazyObjectOption<ObjectIdentifierT extends ${imports.BlankNode} | ${imports.NamedNode}, PartialObjectT extends { ${syntheticNamePrefix}identifier: ObjectIdentifierT }, ResolvedObjectT extends { ${syntheticNamePrefix}identifier: ObjectIdentifierT }> {
+export class ${syntheticNamePrefix}LazyObjectOption<ObjectIdentifierT extends ${imports.BlankNode} | ${imports.NamedNode}, PartialObjectT extends { ${syntheticNamePrefix}identifier: () => ObjectIdentifierT }, ResolvedObjectT extends { ${syntheticNamePrefix}identifier: () => ObjectIdentifierT }> {
   readonly partial: ${imports.Maybe}<PartialObjectT>;
   private readonly resolver: (identifier: ObjectIdentifierT, options?: { preferredLanguages?: readonly string[] }) => Promise<${imports.Either}<Error, ResolvedObjectT>>;
 
@@ -21,7 +21,7 @@ export class ${syntheticNamePrefix}LazyObjectOption<ObjectIdentifierT extends ${
     if (this.partial.isNothing()) {
       return ${imports.Right}(${imports.Maybe}.empty());
     }
-    return (await this.resolver(this.partial.unsafeCoerce().${syntheticNamePrefix}identifier, options)).map(${imports.Maybe}.of);
+    return (await this.resolver(this.partial.unsafeCoerce().${syntheticNamePrefix}identifier(), options)).map(${imports.Maybe}.of);
   }
 }`);
 //# sourceMappingURL=snippets_LazyObjectOption.js.map

package/dist/generators/ts/_snippets/snippets_LazyObjectSet.js

@@ -5,7 +5,7 @@ export const snippets_LazyObjectSet = conditionalOutput(`${syntheticNamePrefix}L
 /**
  * Type of lazy properties that return a set of objects. This is a class instead of an interface so it can be instanceof'd elsewhere.
  */
-export class ${syntheticNamePrefix}LazyObjectSet<ObjectIdentifierT extends ${imports.BlankNode} | ${imports.NamedNode}, PartialObjectT extends { ${syntheticNamePrefix}identifier: ObjectIdentifierT }, ResolvedObjectT extends { ${syntheticNamePrefix}identifier: ObjectIdentifierT }> {
+export class ${syntheticNamePrefix}LazyObjectSet<ObjectIdentifierT extends ${imports.BlankNode} | ${imports.NamedNode}, PartialObjectT extends { ${syntheticNamePrefix}identifier: () => ObjectIdentifierT }, ResolvedObjectT extends { ${syntheticNamePrefix}identifier: () => ObjectIdentifierT }> {
   readonly partials: readonly PartialObjectT[];
   private readonly resolver: (identifiers: readonly ObjectIdentifierT[], options?: { preferredLanguages?: readonly string[] }) => Promise<${imports.Either}<Error, readonly ResolvedObjectT[]>>;
 
@@ -36,7 +36,7 @@ export class ${syntheticNamePrefix}LazyObjectSet<ObjectIdentifierT extends ${imp
       offset = 0;
     }
 
-    return await this.resolver(this.partials.slice(offset, offset + limit).map(partial => partial.${syntheticNamePrefix}identifier), { preferredLanguages: options?.preferredLanguages });
+    return await this.resolver(this.partials.slice(offset, offset + limit).map(partial => partial.${syntheticNamePrefix}identifier()), { preferredLanguages: options?.preferredLanguages });
   }
 }`);
 //# sourceMappingURL=snippets_LazyObjectSet.js.map

package/dist/generators/ts/imports.d.ts

@@ -33,9 +33,7 @@ export declare const imports: {
     readonly Resource: import("ts-poet/build/Import.js").Import;
     readonly ResourceSet: import("ts-poet/build/Import.js").Import;
     readonly Right: import("ts-poet/build/Import.js").Import;
-    readonly sha256: import("ts-poet/build/Import.js").Import;
     readonly sparqljs: import("ts-poet/build/Import.js").Import;
-    readonly uuid: import("ts-poet/build/Import.js").Import;
     readonly Variable: import("ts-poet/build/Import.js").Import;
     readonly z: import("ts-poet/build/Import.js").Import;
 };

package/dist/generators/ts/imports.js

@@ -34,9 +34,7 @@ export const imports = {
     Resource: imp("Resource@@rdfx/resource"),
     ResourceSet: imp("ResourceSet@@rdfx/resource"),
     Right: imp("Right@purify-ts"),
-    sha256: imp("sha256@js-sha256"),
     sparqljs: imp("sparqljs*sparqljs"),
-    uuid: imp("uuid*uuid"),
     Variable: imp("Variable@@rdfjs/types"),
     z: imp("z@zod"),
 };

package/dist/generators/ts/objectSetDeclarations.js

@@ -2,9 +2,7 @@ import { objectSetInterfaceDeclaration } from "./objectSetInterfaceDeclaration.j
 import { rdfjsDatasetObjectSetClassDeclaration } from "./rdfjsDatasetObjectSetClassDeclaration.js";
 import { sparqlObjectSetClassDeclaration } from "./sparqlObjectSetClassDeclaration.js";
 export function objectSetDeclarations({ namedObjectUnionTypes, ...parameters }) {
-    const namedObjectTypes = parameters.namedObjectTypes.filter((namedObjectType) => !namedObjectType.abstract &&
-        !namedObjectType.extern &&
-        !namedObjectType.synthetic);
+    const namedObjectTypes = parameters.namedObjectTypes.filter((namedObjectType) => !namedObjectType.extern && !namedObjectType.synthetic);
     let namedObjectTypesWithRdfFeatureCount = 0;
     let namedObjectTypesWithSparqlFeatureCount = 0;
     for (const namedObjectType of namedObjectTypes) {

package/dist/generators/ts/rdfjsDatasetObjectSetClassDeclaration.js

@@ -15,7 +15,7 @@ export function rdfjsDatasetObjectSetClassDeclaration({ namedObjectTypes, namedO
         query: `query?: ${syntheticNamePrefix}ObjectSet.Query<ObjectFilterT, ObjectIdentifierT>`,
     };
     const typeParameters = {
-        ObjectT: code `ObjectT extends { readonly $identifier: ObjectIdentifierT }`,
+        ObjectT: code `ObjectT extends { readonly $identifier: () => ObjectIdentifierT }`,
         ObjectFilterT: code `ObjectFilterT`,
         ObjectIdentifierT: code `ObjectIdentifierT extends ${imports.BlankNode} | ${imports.NamedNode}`,
     };
@@ -79,7 +79,7 @@ async ${methodSignatures.objectIdentifiers.name}(${methodSignatures.objectIdenti
                 // objectIdentifiersSync
                 code `\
 ${methodSignatures.objectIdentifiers.name}Sync(${methodSignatures.objectIdentifiers.parameters}): ${imports.Either}<Error, readonly ${namedObjectType.identifierTypeAlias}[]> {
-  return this.${methodSignatures.objects.name}Sync(query).map(objects => objects.map(object => object.${syntheticNamePrefix}identifier));
+  return this.${methodSignatures.objects.name}Sync(query).map(objects => objects.map(object => object.${syntheticNamePrefix}identifier()));
 }`,
                 // objects
                 code `\
@@ -92,7 +92,7 @@ async ${methodSignatures.objects.name}(${methodSignatures.objects.parameters}):
                 const fromRdfTypes = namedObjectType.fromRdfTypeVariable
                     .toList()
                     .concat(namedObjectType.descendantFromRdfTypeVariables);
-                return code `{ ${syntheticNamePrefix}filter: ${filterFunction}, ${syntheticNamePrefix}fromRdfResource: ${namedObjectType.staticModuleName}.${syntheticNamePrefix}fromRdfResource, ${syntheticNamePrefix}fromRdfTypes: ${fromRdfTypes.length > 0 ? code `[${joinCode(fromRdfTypes, { on: ", " })}]` : "[]"} }`;
+                return code `{ ${syntheticNamePrefix}filter: ${filterFunction}, ${syntheticNamePrefix}fromRdfResource: ${namedObjectType.name}.${syntheticNamePrefix}fromRdfResource, ${syntheticNamePrefix}fromRdfTypes: ${fromRdfTypes.length > 0 ? code `[${joinCode(fromRdfTypes, { on: ", " })}]` : "[]"} }`;
             };
             switch (namedObjectType.kind) {
                 case "NamedObjectType": {
@@ -105,9 +105,7 @@ ${methodSignatures.objects.name}Sync(${methodSignatures.objects.parameters}): ${
                     return delegatingMethods.concat(code `\
 ${methodSignatures.objects.name}Sync(${methodSignatures.objects.parameters}): ${imports.Either}<Error, readonly ${namedObjectType.name}[]> {
   return this.${syntheticNamePrefix}objectUnionsSync<${namedObjectType.name}, ${namedObjectType.filterType}, ${namedObjectType.identifierTypeAlias}>([
-    ${joinCode(namedObjectType.members
-                        .filter((member) => !member.type.abstract)
-                        .map((member) => runtimeObjectType(namedObjectType.filterFunction, member.type)), { on: ", " })}
+    ${joinCode(namedObjectType.members.map((member) => runtimeObjectType(namedObjectType.filterFunction, member.type)), { on: ", " })}
   ], query);
 }`);
                 default:

package/dist/generators/ts/sparqlObjectSetClassDeclaration.js

@@ -15,7 +15,7 @@ export function sparqlObjectSetClassDeclaration({ namedObjectTypes, namedObjectU
         selectObjectTypeType: code `namedObjectType: { ${syntheticNamePrefix}focusSparqlWherePatterns: ${snippets.FocusSparqlWherePatternsFunction}<ObjectFilterT> }`,
     };
     const typeParameters = {
-        ObjectT: code `ObjectT extends { readonly $identifier: ObjectIdentifierT }`,
+        ObjectT: code `ObjectT extends { readonly $identifier: () => ObjectIdentifierT }`,
         ObjectFilterT: code `ObjectFilterT`,
         ObjectIdentifierT: code `ObjectIdentifierT extends ${imports.BlankNode} | ${imports.NamedNode}`,
     };
@@ -40,7 +40,7 @@ ${joinCode([...namedObjectTypes, ...namedObjectUnionTypes].flatMap((namedObjectT
             namedObjectType,
             queryT: `${syntheticNamePrefix}SparqlObjectSet.Query`,
         });
-        const runtimeObjectType = namedObjectType.staticModuleName;
+        const runtimeObjectType = namedObjectType.name;
         return [
             code `\
 async ${methodSignatures.object.name}(${methodSignatures.object.parameters}): ${methodSignatures.object.returnType} {

package/dist/input/ShapesGraph.d.ts

@@ -2,8 +2,8 @@ import { AbstractShapesGraph } from "@shaclmate/shacl-ast";
 import type { Either } from "purify-ts";
 import type { Logger } from "ts-log";
 import type { Ast } from "../ast/Ast.js";
-import type { TsFeature } from "../enums/TsFeature.js";
 import type { Generator } from "../generators/Generator.js";
+import type { TsFeature } from "../generators/ts/TsFeature.js";
 import * as generated from "./generated.js";
 export declare class ShapesGraph extends AbstractShapesGraph<generated.NodeShape, generated.Ontology, generated.PropertyGroup, generated.PropertyShape> {
     protected readonly typeFunctions: {