@shaclmate/compiler 4.0.24 → 4.0.26

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

@@ -7,7 +7,7 @@ export function NamedObjectType_jsonUiSchemaFunctionDeclaration() {
     }
     const variables = { scopePrefix: code `scopePrefix` };
     const elements = this.parentObjectTypes
-        .map((parentObjectType) => code `${parentObjectType.staticModuleName}.${syntheticNamePrefix}Json.uiSchema({ scopePrefix })`)
+        .map((parentObjectType) => code `${parentObjectType.name}.${syntheticNamePrefix}Json.uiSchema({ scopePrefix })`)
         .concat(this.properties.flatMap((property) => property.jsonUiSchemaElement({ variables }).toList()));
     return Maybe.of(code `\
 export function uiSchema(parameters?: { scopePrefix?: string }): any {

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

@@ -1,9 +1,14 @@
 import { camelCase, trainCase } from "change-case";
 import plur from "plur";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 export function NamedObjectType_objectSetMethodNames() {
-    const prefixSingular = camelCase(this.name);
-    const thisNameParts = trainCase(this.name).split("-");
-    let prefixPlural = camelCase(`${thisNameParts.slice(0, thisNameParts.length - 1).join("")}${plur(thisNameParts[thisNameParts.length - 1])}`);
+    const prefixSingular = camelCase(this.name, {
+        prefixCharacters: syntheticNamePrefix,
+    });
+    const thisNameParts = trainCase(this.name, {
+        prefixCharacters: syntheticNamePrefix,
+    }).split("-");
+    let prefixPlural = camelCase(`${thisNameParts.slice(0, thisNameParts.length - 1).join("")}${plur(thisNameParts[thisNameParts.length - 1])}`, { prefixCharacters: syntheticNamePrefix });
     if (prefixPlural === prefixSingular) {
         // Happens with singular-s nouns like "series"
         prefixPlural = `${prefixPlural}s`;

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

@@ -13,8 +13,8 @@ export function NamedObjectType_propertiesFromJsonFunctionDeclaration() {
     const propertyReturnTypeSignatures = [];
     const returnType = [];
     this.parentObjectTypes.forEach((parentObjectType) => {
-        initializers.push(code `...${parentObjectType.staticModuleName}.${syntheticNamePrefix}propertiesFromJson(${variables.jsonObject})`);
-        returnType.push(code `ReturnType<typeof ${parentObjectType.staticModuleName}.${syntheticNamePrefix}propertiesFromJson>`);
+        initializers.push(code `...${parentObjectType.name}.${syntheticNamePrefix}propertiesFromJson(${variables.jsonObject})`);
+        returnType.push(code `ReturnType<typeof ${parentObjectType.name}.${syntheticNamePrefix}propertiesFromJson>`);
     });
     for (const property of this.properties) {
         const propertyFromJsonStatements = property.fromJsonStatements({

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

@@ -24,11 +24,11 @@ export function NamedObjectType_propertiesFromRdfResourceFunctionDeclaration() {
     const returnType = [];
     this.parentObjectTypes.forEach((parentObjectType, parentObjectTypeI) => {
         chains.push({
-            expression: code `${parentObjectType.staticModuleName}.${syntheticNamePrefix}propertiesFromRdfResource(${variables.resource}, { ...${optionsVariable}, ignoreRdfType: true })`,
+            expression: code `${parentObjectType.name}.${syntheticNamePrefix}propertiesFromRdfResource(${variables.resource}, { ...${optionsVariable}, ignoreRdfType: true })`,
             variable: `${syntheticNamePrefix}super${parentObjectTypeI}`,
         });
         initializers.push(code `...${syntheticNamePrefix}super${parentObjectTypeI}`);
-        returnType.push(code `${snippets.UnwrapR}<ReturnType<typeof ${parentObjectType.staticModuleName}.${syntheticNamePrefix}propertiesFromRdfResource>>`);
+        returnType.push(code `${snippets.UnwrapR}<ReturnType<typeof ${parentObjectType.name}.${syntheticNamePrefix}propertiesFromRdfResource>>`);
     });
     this.fromRdfType.ifJust((fromRdfType) => {
         const fromRdfTypeVariable = this.fromRdfTypeVariable.unsafeCoerce();

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

@@ -3,7 +3,7 @@ import { code, joinCode } from "../ts-poet-wrapper.js";
 export function NamedObjectType_schemaVariableStatement() {
     return code `\
 export const ${syntheticNamePrefix}schema = { properties: { ${joinCode(this.parentObjectTypes
-        .map((parentObjectType) => code `...${parentObjectType.staticModuleName}.${syntheticNamePrefix}schema.properties`)
+        .map((parentObjectType) => code `...${parentObjectType.name}.${syntheticNamePrefix}schema.properties`)
         .concat(this.properties.map((property) => code `${property.name}: ${property.schema}`)), { on: ", " })} } } as const;`;
 }
 //# sourceMappingURL=NamedObjectType_schemaVariableStatement.js.map

package/dist/generators/ts/_NamedObjectType/NamedObjectType_sparqlConstructQueryFunctionDeclaration.d.ts

@@ -1,10 +1,9 @@
 import { Maybe } from "purify-ts";
-import type { TsFeature } from "../../../enums/TsFeature.js";
+import type { TsFeature } from "../TsFeature.js";
 import { type Code } from "../ts-poet-wrapper.js";
 export declare function NamedObjectType_sparqlConstructQueryFunctionDeclaration(this: {
     readonly features: ReadonlySet<TsFeature>;
     readonly filterType: Code;
     readonly name: string;
-    readonly staticModuleName: string;
 }): Maybe<Code>;
 //# sourceMappingURL=NamedObjectType_sparqlConstructQueryFunctionDeclaration.d.ts.map

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

@@ -17,7 +17,7 @@ export function ${syntheticNamePrefix}sparqlConstructQuery({ filter, ignoreRdfTy
     prefixes: prefixes ?? {},
     queryType: "CONSTRUCT",
     template: (queryParameters.template ?? []).concat(
-      ${this.staticModuleName}.${syntheticNamePrefix}focusSparqlConstructTriples({
+      ${this.name}.${syntheticNamePrefix}focusSparqlConstructTriples({
         filter,
         focusIdentifier: subject,
         ignoreRdfType: !!ignoreRdfType,
@@ -27,7 +27,7 @@ export function ${syntheticNamePrefix}sparqlConstructQuery({ filter, ignoreRdfTy
     type: "query",
     where: (queryParameters.where ?? []).concat(
       ${snippets.normalizeSparqlWherePatterns}(
-        ${this.staticModuleName}.${syntheticNamePrefix}focusSparqlWherePatterns({
+        ${this.name}.${syntheticNamePrefix}focusSparqlWherePatterns({
           filter,
           focusIdentifier: subject,
           ignoreRdfType: !!ignoreRdfType,

package/dist/generators/ts/_NamedObjectType/NamedObjectType_sparqlConstructQueryStringFunctionDeclaration.d.ts

@@ -1,9 +1,9 @@
 import { Maybe } from "purify-ts";
-import type { TsFeature } from "../../../enums/TsFeature.js";
+import type { TsFeature } from "../TsFeature.js";
 import { type Code } from "../ts-poet-wrapper.js";
 export declare function NamedObjectType_sparqlConstructQueryStringFunctionDeclaration(this: {
     readonly features: ReadonlySet<TsFeature>;
     readonly filterType: Code;
-    readonly staticModuleName: string;
+    readonly name: string;
 }): Maybe<Code>;
 //# sourceMappingURL=NamedObjectType_sparqlConstructQueryStringFunctionDeclaration.d.ts.map

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

@@ -7,8 +7,8 @@ export function NamedObjectType_sparqlConstructQueryStringFunctionDeclaration()
         return Maybe.empty();
     }
     return Maybe.of(code `\
-export function ${syntheticNamePrefix}sparqlConstructQueryString(parameters: Parameters<typeof ${this.staticModuleName}.${syntheticNamePrefix}sparqlConstructQuery>[0] & ${imports.sparqljs}.GeneratorOptions): string {
-  return new ${imports.sparqljs}.Generator(parameters).stringify(${this.staticModuleName}.${syntheticNamePrefix}sparqlConstructQuery(parameters));
+export function ${syntheticNamePrefix}sparqlConstructQueryString(parameters: Parameters<typeof ${this.name}.${syntheticNamePrefix}sparqlConstructQuery>[0] & ${imports.sparqljs}.GeneratorOptions): string {
+  return new ${imports.sparqljs}.Generator(parameters).stringify(${this.name}.${syntheticNamePrefix}sparqlConstructQuery(parameters));
 }`);
 }
 //# sourceMappingURL=NamedObjectType_sparqlConstructQueryStringFunctionDeclaration.js.map

package/dist/generators/ts/_NamedObjectType/NamedObjectType_toJsonFunctionDeclaration.d.ts

@@ -0,0 +1,5 @@
+import { Maybe } from "purify-ts";
+import type { NamedObjectType } from "../NamedObjectType.js";
+import { type Code } from "../ts-poet-wrapper.js";
+export declare function NamedObjectType_toJsonFunctionDeclaration(this: NamedObjectType): Maybe<Code>;
+//# sourceMappingURL=NamedObjectType_toJsonFunctionDeclaration.d.ts.map

package/dist/generators/ts/_NamedObjectType/{NamedObjectType_toJsonFunctionOrMethodDeclaration.js → NamedObjectType_toJsonFunctionDeclaration.js}

@@ -1,35 +1,13 @@
 import { Maybe } from "purify-ts";
 import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code, joinCode } from "../ts-poet-wrapper.js";
-export function NamedObjectType_toJsonFunctionOrMethodDeclaration() {
+export function NamedObjectType_toJsonFunctionDeclaration() {
     if (!this.features.has("json")) {
         return Maybe.empty();
     }
-    if (this.declarationType === "class" &&
-        this.properties.length === 0 &&
-        this.parentObjectTypes.length > 0) {
-        return Maybe.empty();
-    }
     const jsonObjectMembers = [];
-    const parameters = [];
-    let preamble;
-    switch (this.declarationType) {
-        case "class":
-            if (this.parentObjectTypes.length > 0) {
-                jsonObjectMembers.push(code `...super.${syntheticNamePrefix}toJson()`);
-                preamble = "override ";
-            }
-            else {
-                preamble = "";
-            }
-            break;
-        case "interface":
-            for (const parentObjectType of this.parentObjectTypes) {
-                jsonObjectMembers.push(code `...${parentObjectType.staticModuleName}.${syntheticNamePrefix}toJson(${this.thisVariable})`);
-            }
-            parameters.push(code `${this.thisVariable}: ${this.name}`);
-            preamble = "export function ";
-            break;
+    for (const parentObjectType of this.parentObjectTypes) {
+        jsonObjectMembers.push(code `...${parentObjectType.name}.${syntheticNamePrefix}toJson(${this.thisVariable})`);
     }
     if (this.properties.length > 0) {
         jsonObjectMembers.push(...this.properties.flatMap((property) => property
@@ -56,8 +34,8 @@ export function NamedObjectType_toJsonFunctionOrMethodDeclaration() {
     //     break;
     // }
     return Maybe.of(code `\
-${preamble}${syntheticNamePrefix}toJson(${joinCode(parameters, { on: ", " })}): ${this.jsonType().name} {
+export function ${syntheticNamePrefix}toJson(${this.thisVariable}: ${this.name}): ${this.jsonType().name} {
   return JSON.parse(JSON.stringify({ ${joinCode(jsonObjectMembers, { on: "," })} } satisfies ${this.jsonType().name}));
 }`);
 }
-//# sourceMappingURL=NamedObjectType_toJsonFunctionOrMethodDeclaration.js.map
+//# sourceMappingURL=NamedObjectType_toJsonFunctionDeclaration.js.map

package/dist/generators/ts/_NamedObjectType/NamedObjectType_toRdfResourceFunctionDeclaration.d.ts

@@ -0,0 +1,5 @@
+import { Maybe } from "purify-ts";
+import type { NamedObjectType } from "../NamedObjectType.js";
+import { type Code } from "../ts-poet-wrapper.js";
+export declare function NamedObjectType_toRdfResourceFunctionDeclaration(this: NamedObjectType): Maybe<Code>;
+//# sourceMappingURL=NamedObjectType_toRdfResourceFunctionDeclaration.d.ts.map

package/dist/generators/ts/_NamedObjectType/{NamedObjectType_toRdfResourceFunctionOrMethodDeclaration.js → NamedObjectType_toRdfResourceFunctionDeclaration.js}

@@ -5,36 +5,15 @@ import { rdfjsTermExpression } from "../rdfjsTermExpression.js";
 import { snippets } from "../snippets.js";
 import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code, joinCode } from "../ts-poet-wrapper.js";
-export function NamedObjectType_toRdfResourceFunctionOrMethodDeclaration() {
+export function NamedObjectType_toRdfResourceFunctionDeclaration() {
     if (!this.features.has("rdf")) {
         return Maybe.empty();
     }
-    this.ensureAtMostOneSuperObjectType();
-    let preamble = "";
-    if (this.declarationType === "interface") {
-        preamble = "export function ";
-    }
-    const parameters = [];
-    if (this.declarationType === "interface") {
-        parameters.push(code `${this.thisVariable}: ${this.name}`);
-    }
-    parameters.push(code `options?: Parameters<${snippets.ToRdfResourceFunction}<${this.name}>>[1]`);
     const statements = [
         code `const ${variables.resourceSet} = options?.${variables.resourceSet} ?? new ${imports.ResourceSet}({ dataFactory: ${imports.dataFactory}, dataset: ${imports.datasetFactory}.dataset() });`,
     ];
     if (this.parentObjectTypes.length > 0) {
-        const superToRdfOptions = code `{ ${variables.ignoreRdfType}: true, ${variables.graph}: options?.${variables.graph}, ${variables.resourceSet} }`;
-        let superToRdfCall;
-        switch (this.declarationType) {
-            case "class":
-                preamble = "override ";
-                superToRdfCall = code `super.${syntheticNamePrefix}toRdfResource(${superToRdfOptions})`;
-                break;
-            case "interface":
-                superToRdfCall = code `${this.parentObjectTypes[0].staticModuleName}.${syntheticNamePrefix}toRdfResource(${this.thisVariable}, ${superToRdfOptions})`;
-                break;
-        }
-        statements.push(code `const ${variables.resource} = ${superToRdfCall};`);
+        statements.push(code `const ${variables.resource} = ${this.parentObjectTypes[0].name}.${syntheticNamePrefix}toRdfResource(${this.thisVariable}, { ${variables.ignoreRdfType}: true, ${variables.graph}: options?.${variables.graph}, ${variables.resourceSet} });`);
     }
     else {
         statements.push(code `const ${variables.resource} = ${variables.resourceSet}.resource(${this.thisVariable}.${syntheticNamePrefix}identifier());`);
@@ -56,7 +35,7 @@ export function NamedObjectType_toRdfResourceFunctionOrMethodDeclaration() {
     }
     statements.push(code `return ${variables.resource};`);
     return Maybe.of(code `\
-${preamble}${syntheticNamePrefix}toRdfResource(${joinCode(parameters, { on: "," })}): ${this.toRdfjsResourceType} {
+export function ${syntheticNamePrefix}toRdfResource(${this.thisVariable}: ${this.name}, options?: Parameters<${snippets.ToRdfResourceFunction}<${this.name}>>[1]): ${this.toRdfjsResourceType} {
   ${joinCode(statements)}
 }`);
 }
@@ -66,4 +45,4 @@ const variables = {
     resource: code `resource`,
     resourceSet: code `resourceSet`,
 };
-//# sourceMappingURL=NamedObjectType_toRdfResourceFunctionOrMethodDeclaration.js.map
+//# sourceMappingURL=NamedObjectType_toRdfResourceFunctionDeclaration.js.map

package/dist/generators/ts/_NamedObjectType/NamedObjectType_toStringFunctionDeclarations.d.ts

@@ -0,0 +1,4 @@
+import type { NamedObjectType } from "../NamedObjectType.js";
+import { type Code } from "../ts-poet-wrapper.js";
+export declare function NamedObjectType_toStringFunctionDeclarations(this: NamedObjectType): readonly Code[];
+//# sourceMappingURL=NamedObjectType_toStringFunctionDeclarations.d.ts.map

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

@@ -0,0 +1,40 @@
+import { snippets } from "../snippets.js";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+import { code, joinCode, literalOf } from "../ts-poet-wrapper.js";
+export function NamedObjectType_toStringFunctionDeclarations() {
+    const propertiesToStringRecordProperties = [];
+    if (this.parentObjectTypes.length > 0) {
+        for (const parentObjectType of this.parentObjectTypes) {
+            propertiesToStringRecordProperties.push(code `...${parentObjectType.name}.${syntheticNamePrefix}propertiesToStrings(${this.thisVariable})`);
+        }
+    }
+    for (const property of this.properties) {
+        property
+            .toStringExpression({
+            variables: {
+                value: property.accessExpression({
+                    variables: { object: this.thisVariable },
+                }),
+            },
+        })
+            .ifJust((propertyToStringExpression) => {
+            propertiesToStringRecordProperties.push(code `${literalOf(property.name)}: ${propertyToStringExpression}`);
+        });
+    }
+    const propertiesToStringsReturnExpression = code `${snippets.compactRecord}({${joinCode(propertiesToStringRecordProperties, { on: "," })}})`;
+    const toStringReturnExpression = (propertiesToStrings) => code `\`${this.name}(\${JSON.stringify(${propertiesToStrings})})\``;
+    return [
+        // Use overloads to allow the function to be attached to an instance or used freestanding
+        code `\
+export function ${syntheticNamePrefix}propertiesToStrings(${this.thisVariable}: ${this.name}): Record<string, string> {
+  return ${propertiesToStringsReturnExpression};
+}`,
+        code `\
+export function ${syntheticNamePrefix}toString(this: ${this.name}): string;
+export function ${syntheticNamePrefix}toString(${this.thisVariable}: ${this.name}): string;
+export function ${syntheticNamePrefix}toString(this: ${this.name} | undefined, ${this.thisVariable}?: ${this.name}): string {
+  return ${toStringReturnExpression(code `${syntheticNamePrefix}propertiesToStrings((${this.thisVariable} ?? this)!)`)};
+}`,
+    ];
+}
+//# sourceMappingURL=NamedObjectType_toStringFunctionDeclarations.js.map

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

@@ -8,6 +8,6 @@ export function NamedObjectType_valueSparqlConstructTriplesFunctionDeclaration()
     }
     return Maybe.of(code `\
 export const ${syntheticNamePrefix}valueSparqlConstructTriples: ${snippets.ValueSparqlConstructTriplesFunction}<${this.filterType}, ${this.schemaType}> = ({ filter, ignoreRdfType, valueVariable, variablePrefix }) =>
-  ${this.staticModuleName}.${syntheticNamePrefix}focusSparqlConstructTriples({ filter, focusIdentifier: valueVariable, ignoreRdfType, variablePrefix });`);
+  ${this.name}.${syntheticNamePrefix}focusSparqlConstructTriples({ filter, focusIdentifier: valueVariable, ignoreRdfType, variablePrefix });`);
 }
 //# sourceMappingURL=NamedObjectType_valueSparqlConstructTriplesFunctionDeclaration.js.map

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

@@ -9,7 +9,7 @@ export function NamedObjectType_valueSparqlWherePatternsFunctionDeclaration() {
     return Maybe.of(code `\
 export const ${syntheticNamePrefix}valueSparqlWherePatterns: ${snippets.ValueSparqlWherePatternsFunction}<${this.filterType}, ${this.schemaType}> = ({ filter, ignoreRdfType, preferredLanguages, propertyPatterns, valueVariable, variablePrefix }) =>
   (propertyPatterns as readonly ${snippets.SparqlPattern}[]).concat(
-    ${this.staticModuleName}.${syntheticNamePrefix}focusSparqlWherePatterns({ filter, focusIdentifier: valueVariable, ignoreRdfType, preferredLanguages, variablePrefix })
+    ${this.name}.${syntheticNamePrefix}focusSparqlWherePatterns({ filter, focusIdentifier: valueVariable, ignoreRdfType, preferredLanguages, variablePrefix })
   );`);
 }
 //# sourceMappingURL=NamedObjectType_valueSparqlWherePatternsFunctionDeclaration.js.map

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

@@ -47,10 +47,6 @@ 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`);
         }
@@ -62,9 +58,6 @@ export class ShaclProperty extends AbstractProperty {
             .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,
@@ -86,7 +79,7 @@ export class ShaclProperty extends AbstractProperty {
             context: "property",
         });
         const meta = {
-            id: `${this.namedObjectType.name}-${this.name}`, // id's must be unique
+        // id: `${this.namedObjectType.name}-${this.name}`, // id's must be unique
         };
         this.comment.alt(this.description).ifJust((description) => {
             meta["description"] = description;
@@ -124,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, }) {
@@ -165,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`,
                 },
             })})`,

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

@@ -6,7 +6,7 @@ export const snippets_compactRecord = conditionalOutput(`${syntheticNamePrefix}c
  */  
 function ${syntheticNamePrefix}compactRecord<KeyT extends string, ValueT extends {}>(record: Record<KeyT, ValueT | undefined>): Record<KeyT, ValueT> {
   return \
-    Object.entries(record).reduce((definedProperties, [propertyName, propertyValue]) => {
+    globalThis.Object.entries(record).reduce((definedProperties, [propertyName, propertyValue]) => {
       if (propertyValue !== undefined) {
         definedProperties[propertyName as KeyT] = propertyValue as ValueT;
       }

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

@@ -92,22 +92,20 @@ 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": {
                     return delegatingMethods.concat(code `\
 ${methodSignatures.objects.name}Sync(${methodSignatures.objects.parameters}): ${imports.Either}<Error, readonly ${namedObjectType.name}[]> {
-  return this.${syntheticNamePrefix}objectsSync<${namedObjectType.name}, ${namedObjectType.filterType}, ${namedObjectType.identifierTypeAlias}>(${runtimeObjectType(namedObjectType.filterFunction, namedObjectType)}, query);
+  return this.#objectsSync<${namedObjectType.name}, ${namedObjectType.filterType}, ${namedObjectType.identifierTypeAlias}>(${runtimeObjectType(namedObjectType.filterFunction, namedObjectType)}, query);
 }`);
                 }
                 case "NamedObjectUnionType":
                     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: ", " })}
+  return this.#objectUnionsSync<${namedObjectType.name}, ${namedObjectType.filterType}, ${namedObjectType.identifierTypeAlias}>([
+    ${joinCode(namedObjectType.members.map((member) => runtimeObjectType(namedObjectType.filterFunction, member.type)), { on: ", " })}
   ], query);
 }`);
                 default:
@@ -118,7 +116,7 @@ ${methodSignatures.objects.name}Sync(${methodSignatures.objects.parameters}): ${
         ...(namedObjectTypes.length > 0
             ? [
                 code `\
-protected ${syntheticNamePrefix}objectsSync<${typeParameters.ObjectT}, ${typeParameters.ObjectFilterT}, ${typeParameters.ObjectIdentifierT}>(namedObjectType: ${namedObjectTypeType}, ${parameters.query}): ${imports.Either}<Error, readonly ObjectT[]> {
+#objectsSync<${typeParameters.ObjectT}, ${typeParameters.ObjectFilterT}, ${typeParameters.ObjectIdentifierT}>(namedObjectType: ${namedObjectTypeType}, ${parameters.query}): ${imports.Either}<Error, readonly ObjectT[]> {
   const graph = query?.graph ?? this.${syntheticNamePrefix}graph;
 
   const limit = query?.limit ?? Number.MAX_SAFE_INTEGER;
@@ -210,7 +208,7 @@ protected ${syntheticNamePrefix}objectsSync<${typeParameters.ObjectT}, ${typePar
         ...(namedObjectUnionTypes.length > 0
             ? [
                 code `\
-protected ${syntheticNamePrefix}objectUnionsSync<${typeParameters.ObjectT}, ${typeParameters.ObjectFilterT}, ${typeParameters.ObjectIdentifierT}>(namedObjectTypes: readonly ${namedObjectTypeType}[], ${parameters.query}): ${imports.Either}<Error, readonly ObjectT[]> {
+#objectUnionsSync<${typeParameters.ObjectT}, ${typeParameters.ObjectFilterT}, ${typeParameters.ObjectIdentifierT}>(namedObjectTypes: readonly ${namedObjectTypeType}[], ${parameters.query}): ${imports.Either}<Error, readonly ObjectT[]> {
   const graph = query?.graph ?? this.${syntheticNamePrefix}graph;
 
   const limit = query?.limit ?? Number.MAX_SAFE_INTEGER;