@shaclmate/compiler 4.0.23 → 4.0.25

package/dist/generators/ts/AbstractUnionType.js

@@ -16,7 +16,6 @@ import { code, joinCode, literalOf } from "./ts-poet-wrapper.js";
 export class AbstractUnionType extends AbstractType {
     discriminant;
     identifierType;
-    abstract = false;
     recursive;
     constructor({ identifierType, members, recursive, ...superParameters }) {
         super(superParameters);
@@ -25,9 +24,6 @@ export class AbstractUnionType extends AbstractType {
         this.recursive = recursive;
         this.discriminant = Discriminant.infer(members);
         this.lazyMembers = () => members.map((member, memberI) => {
-            if (member.type.abstract) {
-                return { abstract: true, discriminantValues: [], type: member.type };
-            }
             let discriminantValues;
             invariant(this.discriminant.memberValues.length === members.length);
             switch (this.discriminant.kind) {
@@ -69,9 +65,7 @@ export class AbstractUnionType extends AbstractType {
                 default:
                     throw this.discriminant;
             }
-            if (discriminantValues.length === 0) {
-                return { abstract: true, discriminantValues: [], type: member.type };
-            }
+            invariant(discriminantValues.length > 0);
             const typeCheck = (json) => (instance) => {
                 const discriminant = this.discriminant; // To get type narrowing to work
                 if (discriminant.kind === "typeof") {
@@ -82,13 +76,12 @@ export class AbstractUnionType extends AbstractType {
                         case "NamedObjectUnionType":
                         case "NamedUnionType":
                         case "NamedObjectType":
-                            return code `${member.type.staticModuleName}.is${member.type.name}(${instance})`;
+                            return code `${member.type.name}.is${member.type.name}(${instance})`;
                     }
                 }
                 return code `(${joinCode(discriminantValues.map((discriminantValue) => code `${instance}.${discriminant.name} === ${literalOf(discriminantValue)}`), { on: " || " })})`;
             };
             return {
-                abstract: false,
                 discriminantValues,
                 jsonType: member.type.jsonType({
                     includeDiscriminantProperty: this.discriminant.kind === "intrinsic" ||
@@ -150,7 +143,7 @@ export class AbstractUnionType extends AbstractType {
                     },
                 ];
             case "typeof":
-                return this.concreteMembers.map(({ primaryDiscriminantValue, type, typeCheck }) => ({
+                return this.members.map(({ primaryDiscriminantValue, type, typeCheck }) => ({
                     conversionExpression: (value) => value,
                     sourceTypeCheckExpression: (value) => typeCheck(value),
                     sourceTypeName: type.name,
@@ -202,7 +195,7 @@ export class AbstractUnionType extends AbstractType {
             //   kind: '"extrinsic" | "intrinsic" | "typeof"',
             // },
             kind: code `${literalOf(this.kind.substring(0, this.kind.length - "Type".length))}`,
-            members: code `{ ${joinCode(this.concreteMembers.map(({ type, primaryDiscriminantValue }) => code `readonly ${literalOf(primaryDiscriminantValue)}: ${{
+            members: code `{ ${joinCode(this.members.map(({ type, primaryDiscriminantValue }) => code `readonly ${literalOf(primaryDiscriminantValue)}: ${{
                 discriminantValues: code `readonly (number | string)[]`,
                 type: type.schemaType,
             }}`), { on: ";" })} }`,
@@ -218,15 +211,12 @@ export class AbstractUnionType extends AbstractType {
         return set;
     }
     get typeofs() {
-        return NonEmptyList.fromArray(this.concreteMembers.flatMap((member) => member.type.typeofs)).unsafeCoerce();
-    }
-    get concreteMembers() {
-        return this.members.filter((member) => !member.abstract);
+        return NonEmptyList.fromArray(this.members.flatMap((member) => member.type.typeofs)).unsafeCoerce();
     }
     get inlineEqualsFunction() {
         return code `\
 ((left: ${this.name}, right: ${this.name}) => {
-${joinCode(this.concreteMembers.map(({ type, typeCheck, unwrap }) => code `if (${typeCheck(code `left`)} && ${typeCheck(code `right`)}) {
+${joinCode(this.members.map(({ type, typeCheck, unwrap }) => code `if (${typeCheck(code `left`)} && ${typeCheck(code `right`)}) {
   return ${type.equalsFunction}(${unwrap(code `left`)} as ${type.name}, ${unwrap(code `right`)} as ${type.name});
 }`))}
 
@@ -239,11 +229,11 @@ ${joinCode(this.concreteMembers.map(({ type, typeCheck, unwrap }) => code `if ($
 ${joinCode([
             ...this.identifierType
                 .map((identifierType) => code `\
-if (filter.${syntheticNamePrefix}identifier !== undefined && !${identifierType.filterFunction}(filter.${syntheticNamePrefix}identifier, value.${syntheticNamePrefix}identifier)) {
+if (filter.${syntheticNamePrefix}identifier !== undefined && !${identifierType.filterFunction}(filter.${syntheticNamePrefix}identifier, value.${syntheticNamePrefix}identifier())) {
   return false;
 }`)
                 .toList(),
-            ...this.concreteMembers.map(({ primaryDiscriminantValue, type, typeCheck, unwrap }) => code `\
+            ...this.members.map(({ primaryDiscriminantValue, type, typeCheck, unwrap }) => code `\
 if (filter.on?.[${literalOf(primaryDiscriminantValue)}] !== undefined && ${typeCheck(code `value`)}) {
   if (!${type.filterFunction}(filter.on[${literalOf(primaryDiscriminantValue)}], ${unwrap(code `value`)})) {
     return false;
@@ -258,13 +248,13 @@ if (filter.on?.[${literalOf(primaryDiscriminantValue)}] !== undefined && ${typeC
         return code `\
   {
    ${this.identifierType.map((identifierType) => code `readonly ${syntheticNamePrefix}identifier?: ${identifierType.filterType};`).orDefault(code ``)}
-   readonly on?: { ${joinCode(this.concreteMembers.map(({ type, primaryDiscriminantValue }) => code `readonly ${literalOf(primaryDiscriminantValue)}?: ${type.filterType}`), { on: ";" })} }
+   readonly on?: { ${joinCode(this.members.map(({ type, primaryDiscriminantValue }) => code `readonly ${literalOf(primaryDiscriminantValue)}?: ${type.filterType}`), { on: ";" })} }
   }`;
     }
     get inlineFromJsonFunction() {
         return code `\
 ((value: ${this.jsonType().name}): ${this.name} => {
-${joinCode(this.concreteMembers.map(({ jsonType, jsonTypeCheck, type, unwrap, wrap }) => code `if (${jsonTypeCheck(code `value`)}) { return ${wrap(type.fromJsonExpression({
+${joinCode(this.members.map(({ jsonType, jsonTypeCheck, type, unwrap, wrap }) => code `if (${jsonTypeCheck(code `value`)}) { return ${wrap(type.fromJsonExpression({
             variables: {
                 value: code `(${unwrap(code `value`)} as ${jsonType})`,
             },
@@ -287,7 +277,7 @@ ${joinCode(this.concreteMembers.map(({ jsonType, jsonTypeCheck, type, unwrap, wr
 (((values, _options) =>
     values.chain(values => values.chainMap(value => {
       const valueAsValues = ${imports.Right}(value.toValues());
-      return ${this.concreteMembers.reduce((expression, { type, primaryDiscriminantValue }, memberI) => {
+      return ${this.members.reduce((expression, { type, primaryDiscriminantValue }, memberI) => {
             let typeExpression = type.fromRdfResourceValuesExpression({
                 variables: {
                     context: variables.context,
@@ -317,9 +307,9 @@ ${joinCode(this.concreteMembers.map(({ jsonType, jsonTypeCheck, type, unwrap, wr
         const discriminant = this.discriminant; // To get type narrowing to work
         switch (discriminant.kind) {
             case "extrinsic":
-                return code `${imports.z}.discriminatedUnion("${discriminant.name}", [${joinCode(this.concreteMembers.map(({ type, primaryDiscriminantValue }) => code `${imports.z}.object({ ${discriminant.name}: ${imports.z}.literal(${literalOf(primaryDiscriminantValue)}), value: ${type.jsonSchema({ context: "type" })} })`), { on: "," })}]).readonly()`;
+                return code `${imports.z}.discriminatedUnion("${discriminant.name}", [${joinCode(this.members.map(({ type, primaryDiscriminantValue }) => code `${imports.z}.object({ ${discriminant.name}: ${imports.z}.literal(${literalOf(primaryDiscriminantValue)}), value: ${type.jsonSchema({ context: "type" })} })`), { on: "," })}]).readonly()`;
             case "hybrid":
-                return code `${imports.z}.discriminatedUnion("${discriminant.name}", [${joinCode(this.concreteMembers.map(({ primaryDiscriminantValue, type }, memberI) => {
+                return code `${imports.z}.discriminatedUnion("${discriminant.name}", [${joinCode(this.members.map(({ primaryDiscriminantValue, type }, memberI) => {
                     switch (discriminant.memberValues[memberI].kind) {
                         case "extrinsic":
                             return code `${imports.z}.object({ ${discriminant.name}: ${imports.z}.literal(${literalOf(primaryDiscriminantValue)}), value: ${type.jsonSchema({ context: "type" })} })`;
@@ -333,12 +323,12 @@ ${joinCode(this.concreteMembers.map(({ jsonType, jsonTypeCheck, type, unwrap, wr
                     }
                 }), { on: "," })}]).readonly()`;
             case "intrinsic":
-                return code `${imports.z}.discriminatedUnion("${discriminant.name}", [${joinCode(this.concreteMembers.map(({ type }) => type.jsonSchema({
+                return code `${imports.z}.discriminatedUnion("${discriminant.name}", [${joinCode(this.members.map(({ type }) => type.jsonSchema({
                     includeDiscriminantProperty: true,
                     context: "type",
                 })), { on: "," })}]).readonly()`;
             case "typeof":
-                return code `${imports.z}.union([${joinCode(this.concreteMembers.map(({ type }) => type.jsonSchema({ context: "type" })), { on: "," })}]).readonly()`;
+                return code `${imports.z}.union([${joinCode(this.members.map(({ type }) => type.jsonSchema({ context: "type" })), { on: "," })}]).readonly()`;
             default:
                 throw discriminant;
         }
@@ -347,9 +337,9 @@ ${joinCode(this.concreteMembers.map(({ jsonType, jsonTypeCheck, type, unwrap, wr
         const discriminant = this.discriminant; // To get type narrowing to work
         switch (discriminant.kind) {
             case "extrinsic":
-                return new AbstractType.JsonType(code `(${joinCode(this.concreteMembers.map(({ jsonType, primaryDiscriminantValue }) => code `{ ${discriminant.name}: ${literalOf(primaryDiscriminantValue)}, value: ${jsonType} }`), { on: "|" })})`);
+                return new AbstractType.JsonType(code `(${joinCode(this.members.map(({ jsonType, primaryDiscriminantValue }) => code `{ ${discriminant.name}: ${literalOf(primaryDiscriminantValue)}, value: ${jsonType} }`), { on: "|" })})`);
             case "hybrid":
-                return new AbstractType.JsonType(code `(${joinCode(this.concreteMembers.map(({ jsonType, primaryDiscriminantValue }, memberI) => {
+                return new AbstractType.JsonType(code `(${joinCode(this.members.map(({ jsonType, primaryDiscriminantValue }, memberI) => {
                     switch (discriminant.memberValues[memberI].kind) {
                         case "extrinsic":
                             return code `{ ${discriminant.name}: ${literalOf(primaryDiscriminantValue)}, value: ${jsonType} }`;
@@ -361,7 +351,7 @@ ${joinCode(this.concreteMembers.map(({ jsonType, jsonTypeCheck, type, unwrap, wr
                 }), { on: "|" })})`);
             case "intrinsic":
             case "typeof":
-                return new AbstractType.JsonType(joinCode(this.concreteMembers.map(({ jsonType }) => code `${jsonType}`), { on: "|" }));
+                return new AbstractType.JsonType(joinCode(this.members.map(({ jsonType }) => code `${jsonType}`), { on: "|" }));
             default:
                 throw discriminant;
         }
@@ -370,9 +360,9 @@ ${joinCode(this.concreteMembers.map(({ jsonType, jsonTypeCheck, type, unwrap, wr
         const discriminant = this.discriminant; // To get type narrowing to work
         switch (discriminant.kind) {
             case "extrinsic":
-                return code `(${joinCode(this.concreteMembers.map(({ type, primaryDiscriminantValue }) => code `{ ${discriminant.name}: ${literalOf(primaryDiscriminantValue)}, value: ${type.name} }`), { on: "|" })})`;
+                return code `(${joinCode(this.members.map(({ type, primaryDiscriminantValue }) => code `{ ${discriminant.name}: ${literalOf(primaryDiscriminantValue)}, value: ${type.name} }`), { on: "|" })})`;
             case "hybrid":
-                return code `(${joinCode(this.concreteMembers.map(({ primaryDiscriminantValue, type }, memberI) => {
+                return code `(${joinCode(this.members.map(({ primaryDiscriminantValue, type }, memberI) => {
                     switch (discriminant.memberValues[memberI].kind) {
                         case "extrinsic":
                             return code `{ ${discriminant.name}: ${literalOf(primaryDiscriminantValue)}, value: ${type.name} }`;
@@ -398,7 +388,7 @@ ${joinCode(this.concreteMembers.map(({ jsonType, jsonTypeCheck, type, unwrap, wr
     get inlineToJsonFunction() {
         return code `\
 ((value: ${this.name}): ${this.jsonType().name} => {
-${joinCode(this.concreteMembers.map(({ typeCheck, typeToJsonExpression, unwrap, wrap }) => code `if (${typeCheck(code `value`)}) { return ${wrap(typeToJsonExpression(unwrap(code `value`)))}; }`))}
+${joinCode(this.members.map(({ typeCheck, typeToJsonExpression, unwrap, wrap }) => code `if (${typeCheck(code `value`)}) { return ${wrap(typeToJsonExpression(unwrap(code `value`)))}; }`))}
 
   throw new Error("unable to serialize to JSON");
 })`;
@@ -418,7 +408,7 @@ ${joinCode(this.concreteMembers.map(({ typeCheck, typeToJsonExpression, unwrap,
                     throw new Error();
             }
         }), { on: " | " })})[] => {
-${joinCode(this.concreteMembers.map(({ type, unwrap, typeCheck }) => code `if (${typeCheck(code `value`)}) { return ${type.toRdfResourceValuesExpression({
+${joinCode(this.members.map(({ type, unwrap, typeCheck }) => code `if (${typeCheck(code `value`)}) { return ${type.toRdfResourceValuesExpression({
             variables: {
                 graph: code `_options.graph`,
                 propertyPath: code `_options.propertyPath`,
@@ -434,7 +424,7 @@ ${joinCode(this.concreteMembers.map(({ type, unwrap, typeCheck }) => code `if ($
     get inlineToStringFunction() {
         return code `\
 ((value: ${this.name}): string => {
-${joinCode(this.concreteMembers.map(({ type, typeCheck, unwrap }) => code `if (${typeCheck(code `value`)}) { return ${type.toStringExpression({
+${joinCode(this.members.map(({ type, typeCheck, unwrap }) => code `if (${typeCheck(code `value`)}) { return ${type.toStringExpression({
             variables: { value: unwrap(code `value`) },
         })}; }`))}
 
@@ -446,7 +436,7 @@ ${joinCode(this.concreteMembers.map(({ type, typeCheck, unwrap }) => code `if ($
 ((({ ignoreRdfType, filter, schema, ...otherParameters }) => {
   let triples: ${imports.sparqljs}.Triple[] = [];
 
-  ${joinCode(this.concreteMembers.map(({ type, primaryDiscriminantValue }) => code `\
+  ${joinCode(this.members.map(({ type, primaryDiscriminantValue }) => code `\
 triples = triples.concat(${type.valueSparqlConstructTriplesFunction}({ ...otherParameters, filter: filter?.on?.[${literalOf(primaryDiscriminantValue)}], ignoreRdfType: false, schema: schema.members[${literalOf(primaryDiscriminantValue)}].type }));`))}
   
   return triples;
@@ -457,7 +447,7 @@ triples = triples.concat(${type.valueSparqlConstructTriplesFunction}({ ...otherP
 ((({ filter, schema, ...otherParameters }) => {
   const unionPatterns: ${imports.sparqljs}.GroupPattern[] = [];
 
-  ${joinCode(this.concreteMembers.map(({ type, primaryDiscriminantValue }) => code `\
+  ${joinCode(this.members.map(({ type, primaryDiscriminantValue }) => code `\
 unionPatterns.push({ patterns: ${type.valueSparqlWherePatternsFunction}({ ...otherParameters, filter: filter?.on?.[${literalOf(primaryDiscriminantValue)}], ignoreRdfType: false, schema: schema.members[${literalOf(primaryDiscriminantValue)}].type }).concat(), type: "group" });`))}
   
   return [{ patterns: unionPatterns, type: "union" }];
@@ -466,7 +456,7 @@ unionPatterns.push({ patterns: ${type.valueSparqlWherePatternsFunction}({ ...oth
     get schemaObject() {
         return {
             ...super.schemaObject,
-            members: code `{ ${joinCode(this.concreteMembers.map(({ discriminantValues, type, primaryDiscriminantValue }) => code `${literalOf(primaryDiscriminantValue)}: ${{
+            members: code `{ ${joinCode(this.members.map(({ discriminantValues, type, primaryDiscriminantValue }) => code `${literalOf(primaryDiscriminantValue)}: ${{
                 discriminantValues: discriminantValues,
                 type: type.schema,
             }}`), { on: "," })} }`,
@@ -476,7 +466,7 @@ unionPatterns.push({ patterns: ${type.valueSparqlWherePatternsFunction}({ ...oth
         return Maybe.empty();
     }
     inlineHashStatements({ depth, variables, }) {
-        return this.concreteMembers.map(({ type, unwrap, typeCheck }) => code `if (${typeCheck(variables.value)}) { ${joinCode(type
+        return this.members.map(({ type, unwrap, typeCheck }) => code `if (${typeCheck(variables.value)}) { ${joinCode(type
             .hashStatements({
             depth: depth + 1,
             variables: {
@@ -509,9 +499,6 @@ __decorate([
 __decorate([
     Memoize()
 ], AbstractUnionType.prototype, "typeofs", null);
-__decorate([
-    Memoize()
-], AbstractUnionType.prototype, "concreteMembers", null);
 __decorate([
     Memoize()
 ], AbstractUnionType.prototype, "inlineEqualsFunction", null);

package/dist/generators/ts/LazyObjectOptionType.js

@@ -9,6 +9,7 @@ import { Memoize } from "typescript-memoize";
 import { AbstractLazyObjectType } from "./AbstractLazyObjectType.js";
 import { imports } from "./imports.js";
 import { snippets } from "./snippets.js";
+import { syntheticNamePrefix } from "./syntheticNamePrefix.js";
 import { code } from "./ts-poet-wrapper.js";
 const Super = (AbstractLazyObjectType);
 export class LazyObjectOptionType extends Super {
@@ -30,12 +31,12 @@ export class LazyObjectOptionType extends Super {
         const conversions = super.conversions.concat();
         if (this.partialType.itemType.kind === "NamedObjectType") {
             conversions.push({
-                conversionExpression: (value) => code `new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}: ${value}.map(object => ${this.partialType.itemType.newExpression({ parameters: code `object` })}), resolver: async () => ${imports.Right}((${value} as ${imports.Maybe}<${this.resolveType.itemType.name}>).unsafeCoerce()) })`,
+                conversionExpression: (value) => code `new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}: ${value}.map(${this.partialType.itemType.name}.${syntheticNamePrefix}create), resolver: async () => ${imports.Right}((${value} as ${imports.Maybe}<${this.resolveType.itemType.name}>).unsafeCoerce()) })`,
                 sourceTypeCheckExpression: (value) => code `${imports.Maybe}.isMaybe(${value})`,
                 sourceTypeName: code `${imports.Maybe}<${this.resolveType.itemType.name}>`,
                 sourceTypeof: "object",
             }, {
-                conversionExpression: (value) => code `new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}: ${imports.Maybe}.of(${this.partialType.itemType.newExpression({ parameters: value })}), resolver: async () => ${imports.Right}(${value} as ${this.resolveType.itemType.name}) })`,
+                conversionExpression: (value) => code `new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}: ${imports.Maybe}.of(${this.partialType.itemType.name}.${syntheticNamePrefix}create(${value})), resolver: async () => ${imports.Right}(${value} as ${this.resolveType.itemType.name}) })`,
                 // Don't check instanceof value since the NamedObjectUnionType may be an interface
                 // Rely on the fact that this will be the last type check on an object
                 sourceTypeCheckExpression: (value) => code `typeof ${value} === "object"`,

package/dist/generators/ts/LazyObjectSetType.js

@@ -9,6 +9,7 @@ import { Memoize } from "typescript-memoize";
 import { AbstractLazyObjectType } from "./AbstractLazyObjectType.js";
 import { imports } from "./imports.js";
 import { snippets } from "./snippets.js";
+import { syntheticNamePrefix } from "./syntheticNamePrefix.js";
 import { code } from "./ts-poet-wrapper.js";
 export class LazyObjectSetType extends AbstractLazyObjectType {
     graphqlArgs = Maybe.of({
@@ -36,7 +37,7 @@ export class LazyObjectSetType extends AbstractLazyObjectType {
         const conversions = super.conversions.concat();
         if (this.partialType.itemType.kind === "NamedObjectType") {
             conversions.push({
-                conversionExpression: (value) => code `new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}: ${value}.map(object => ${this.partialType.itemType.newExpression({ parameters: code `object` })}), resolver: async () => ${imports.Right}(${value} as readonly ${this.resolveType.itemType.name}[]) })`,
+                conversionExpression: (value) => code `new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}: ${value}.map(${this.partialType.itemType.name}.${syntheticNamePrefix}create), resolver: async () => ${imports.Right}(${value} as readonly ${this.resolveType.itemType.name}[]) })`,
                 sourceTypeCheckExpression: (value) => code `typeof ${value} === "object"`,
                 sourceTypeName: code `readonly ${this.resolveType.itemType.name}[]`,
                 sourceTypeof: "object",

package/dist/generators/ts/LazyObjectType.js

@@ -2,6 +2,7 @@ import { Maybe } from "purify-ts";
 import { AbstractLazyObjectType } from "./AbstractLazyObjectType.js";
 import { imports } from "./imports.js";
 import { snippets } from "./snippets.js";
+import { syntheticNamePrefix } from "./syntheticNamePrefix.js";
 import { code } from "./ts-poet-wrapper.js";
 export class LazyObjectType extends AbstractLazyObjectType {
     graphqlArgs = Maybe.empty();
@@ -22,7 +23,7 @@ export class LazyObjectType extends AbstractLazyObjectType {
         const conversions = super.conversions.concat();
         if (this.partialType.kind === "NamedObjectType") {
             conversions.push({
-                conversionExpression: (value) => code `new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}: ${this.partialType.newExpression({ parameters: value })}, resolver: async () => ${imports.Right}(${value} as ${this.resolveType.name}) })`,
+                conversionExpression: (value) => code `new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}: ${this.partialType.name}.${syntheticNamePrefix}create(${value}), resolver: async () => ${imports.Right}(${value} as ${this.resolveType.name}) })`,
                 // Don't check instanceof value since the NamedObjectType may be an interface
                 // Rely on the fact that this will be the last type check on an object
                 sourceTypeCheckExpression: (value) => code `typeof ${value} === "object"`,

package/dist/generators/ts/ListType.d.ts

@@ -1,6 +1,4 @@
 import type { NamedNode } from "@rdfjs/types";
-import type { Maybe } from "purify-ts";
-import type { IdentifierMintingStrategy } from "../../enums/IdentifierMintingStrategy.js";
 import { AbstractCollectionType } from "./AbstractCollectionType.js";
 import type { AnonymousUnionType } from "./AnonymousUnionType.js";
 import type { BigDecimalType } from "./BigDecimalType.js";
@@ -22,13 +20,11 @@ import type { TermType } from "./TermType.js";
 import type { Type } from "./Type.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare class ListType<ItemTypeT extends ListType.ItemType> extends AbstractCollectionType<ItemTypeT> {
-    private readonly identifierMintingStrategy;
     private readonly identifierNodeKind;
     private readonly toRdfTypes;
     readonly kind = "ListType";
-    constructor({ identifierNodeKind, identifierMintingStrategy, toRdfTypes, ...superParameters }: {
+    constructor({ identifierNodeKind, toRdfTypes, ...superParameters }: {
         identifierNodeKind: ListType<ItemTypeT>["identifierNodeKind"];
-        identifierMintingStrategy: Maybe<IdentifierMintingStrategy>;
         toRdfTypes: readonly NamedNode[];
     } & ConstructorParameters<typeof AbstractCollectionType<ItemTypeT>>[0]);
     get valueSparqlConstructTriplesFunction(): Code;

package/dist/generators/ts/ListType.js

@@ -12,14 +12,12 @@ import { rdfjsTermExpression } from "./rdfjsTermExpression.js";
 import { snippets } from "./snippets.js";
 import { code, joinCode } from "./ts-poet-wrapper.js";
 export class ListType extends AbstractCollectionType {
-    identifierMintingStrategy;
     identifierNodeKind;
     toRdfTypes;
     kind = "ListType";
-    constructor({ identifierNodeKind, identifierMintingStrategy, toRdfTypes, ...superParameters }) {
+    constructor({ identifierNodeKind, toRdfTypes, ...superParameters }) {
         super(superParameters);
         this.identifierNodeKind = identifierNodeKind;
-        this.identifierMintingStrategy = identifierMintingStrategy.orDefault(identifierNodeKind === "BlankNode" ? "blankNode" : "sha256");
         this.toRdfTypes = toRdfTypes;
     }
     get valueSparqlConstructTriplesFunction() {
@@ -48,43 +46,26 @@ export class ListType extends AbstractCollectionType {
         return new AbstractCollectionType.JsonType(code `${!this.mutable ? "readonly " : ""}(${this.itemType.jsonType().name})[]`);
     }
     toRdfResourceValuesExpression({ variables, }) {
-        let listIdentifier;
+        let mintListIdentifierFunction;
+        let mintSubListIdentifierFunction;
         let resourceTypeName;
-        let subListIdentifier;
         switch (this.identifierNodeKind) {
             case "BlankNode": {
-                listIdentifier =
-                    subListIdentifier = code `${imports.dataFactory}.blankNode()`;
+                mintListIdentifierFunction =
+                    mintSubListIdentifierFunction = code `(() => ${imports.dataFactory}.blankNode())`;
                 resourceTypeName = code `${imports.Resource}<${imports.BlankNode}>`;
                 break;
             }
             case "IRI": {
-                switch (this.identifierMintingStrategy) {
-                    case "blankNode":
-                        throw new RangeError(this.identifierMintingStrategy);
-                    case "sha256":
-                        listIdentifier = code `${imports.dataFactory}.namedNode(\`urn:shaclmate:list:\${${variables.value}.reduce(
-        (hasher, item) => {
-          ${joinCode(this.itemType.hashStatements({ depth: 0, variables: { hasher: code `hasher`, value: code `item` } }).concat())}
-          return hasher;
-        },
-        ${imports.sha256}.create(),
-      )}\`)`;
-                        break;
-                    case "uuidv4":
-                        listIdentifier = code `${imports.dataFactory}.namedNode(\`urn:shaclmate:list:\${${imports.uuid}.v4()}\`)`;
-                        break;
-                }
                 resourceTypeName = code `${imports.Resource}<${imports.NamedNode}>`;
-                subListIdentifier = code `${imports.dataFactory}.namedNode(\`\${listResource.identifier.value}:\${itemIndex}\`)`;
-                break;
+                throw new RangeError("list IRI minting is unsupported");
             }
         }
         return code `[${variables.value}.length > 0 ? ${variables.value}.reduce(({ currentSubListResource, listResource }, item, itemIndex, list) => {
     if (itemIndex === 0) {
       currentSubListResource = listResource;
     } else {
-      const newSubListResource = ${variables.resourceSet}.resource(${subListIdentifier});
+      const newSubListResource = ${variables.resourceSet}.resource(${mintSubListIdentifierFunction}());
       currentSubListResource!.add(${rdfjsTermExpression(rdf.rest, { logger: this.logger })}, newSubListResource.identifier, ${variables.graph});
       currentSubListResource = newSubListResource;
     }
@@ -101,7 +82,7 @@ export class ListType extends AbstractCollectionType {
   },
   {
     currentSubListResource: null,
-    listResource: resourceSet.resource(${listIdentifier}),
+    listResource: resourceSet.resource(${mintListIdentifierFunction}()),
   } as {
     currentSubListResource: ${resourceTypeName} | null;
     listResource: ${resourceTypeName};

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

@@ -1,9 +1,6 @@
 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";
@@ -11,13 +8,12 @@ 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 { TsFeature } from "./TsFeature.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>;
@@ -26,13 +22,10 @@ export declare class NamedObjectType extends AbstractType {
     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;
+    constructor({ extern, features, fromRdfType, identifierType, imports, lazyAncestorObjectTypes, lazyChildObjectTypes, lazyDescendantObjectTypes, lazyDiscriminantProperty, lazyParentObjectTypes, lazyProperties, name, recursive, synthetic, toRdfTypes, ...superParameters }: {
         comment: Maybe<string>;
-        declarationType: TsObjectDeclarationType;
         extern: boolean;
         features: ReadonlySet<TsFeature>;
         fromRdfType: Maybe<NamedNode>;
@@ -42,13 +35,11 @@ export declare class NamedObjectType extends AbstractType {
         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]);
@@ -67,12 +58,9 @@ export declare class NamedObjectType extends AbstractType {
     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;
@@ -93,24 +81,17 @@ export declare class NamedObjectType extends AbstractType {
     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;
     toStringExpression({ variables, }: Parameters<AbstractType["toStringExpression"]>[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 = {