@shaclmate/compiler 4.0.23 → 4.0.25

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

@@ -0,0 +1,25 @@
+import { Maybe } from "purify-ts";
+import { snippets } from "../snippets.js";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+import { code, joinCode } from "../ts-poet-wrapper.js";
+export function NamedObjectType_equalsFunctionDeclaration() {
+    if (!this.features.has("equals")) {
+        return Maybe.empty();
+    }
+    const chain = [];
+    // For every parent, find the nearest equals implementation
+    for (const parentObjectType of this.parentObjectTypes) {
+        chain.push(code `${parentObjectType.name}.${syntheticNamePrefix}equals(left, right)`);
+    }
+    for (const property of this.properties) {
+        if (property.kind === "DiscriminantProperty") {
+            continue;
+        }
+        chain.push(code `(${property.type.equalsFunction})(${property.accessExpression({ variables: { object: code `left` } })}, ${property.accessExpression({ variables: { object: code `right` } })}).mapLeft(propertyValuesUnequal => ({ left, right, propertyName: "${property.name}", propertyValuesUnequal, type: "property" as const }))`);
+    }
+    return Maybe.of(code `\
+export function ${syntheticNamePrefix}equals(left: ${this.name}, right: ${this.name}): ${snippets.EqualsResult} {
+  return ${joinCode(chain.map((chainPart, chainPartI) => chainPartI === 0 ? chainPart : code `chain(() => ${chainPart})`), { on: "." })}
+}`);
+}
+//# sourceMappingURL=NamedObjectType_equalsFunctionDeclaration.js.map

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

@@ -5,10 +5,10 @@ export function NamedObjectType_filterFunctionDeclaration() {
     for (const parentObjectType of this.parentObjectTypes) {
         statements.push(code `if (!${parentObjectType.filterFunction}(filter, value)) { return false; }`);
     }
-    if (this.ownProperties.length > 0) {
-        for (const ownProperty of this.ownProperties) {
-            ownProperty.filterProperty.ifJust(({ name }) => {
-                statements.push(code `if (filter.${name} !== undefined && !${ownProperty.type.filterFunction}(filter.${name}, value.${ownProperty.name})) { return false; }`);
+    if (this.properties.length > 0) {
+        for (const property of this.properties) {
+            property.filterProperty.ifJust(({ name }) => {
+                statements.push(code `if (filter.${name} !== undefined && !${property.type.filterFunction}(filter.${name}, ${property.accessExpression({ variables: { object: code `value` } })})) { return false; }`);
             });
         }
     }

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

@@ -14,7 +14,7 @@ export function NamedObjectType_filterTypeDeclaration() {
         }
     }
     for (const parentObjectType of this.parentObjectTypes) {
-        members.push(code `${parentObjectType.staticModuleName}.${syntheticNamePrefix}Filter`);
+        members.push(code `${parentObjectType.name}.${syntheticNamePrefix}Filter`);
     }
     return code `\
 export type ${syntheticNamePrefix}Filter = ${members.length > 0 ? joinCode(members, { on: " & " }) : "object"};`;

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

@@ -19,7 +19,7 @@ export function NamedObjectType_focusSparqlConstructTriplesFunctionDeclaration()
     let triplesVariableDeclarationKeyword = "const";
     const statements = [];
     for (const parentObjectType of this.parentObjectTypes) {
-        statements.push(code `triples = triples.concat(${parentObjectType.staticModuleName}.${syntheticNamePrefix}focusSparqlConstructTriples(${{ filter: variables.filter, focusIdentifier: variables.focusIdentifier, ignoreRdfType: true, variablePrefix: variables.variablePrefix }}));`);
+        statements.push(code `triples = triples.concat(${parentObjectType.name}.${syntheticNamePrefix}focusSparqlConstructTriples(${{ filter: variables.filter, focusIdentifier: variables.focusIdentifier, ignoreRdfType: true, variablePrefix: variables.variablePrefix }}));`);
         triplesVariableDeclarationKeyword = "let";
     }
     if (this.fromRdfType.isJust()) {
@@ -31,7 +31,7 @@ if (!parameters?.ignoreRdfType) {
   );
 }`);
     }
-    for (const property of this.ownProperties) {
+    for (const property of this.properties) {
         if (property.recursive) {
             continue;
         }

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

@@ -21,7 +21,7 @@ export function NamedObjectType_focusSparqlWherePatternsFunctionDeclaration() {
     const statements = [];
     for (const parentObjectType of this.parentObjectTypes) {
         statements.push(code `\
-patterns = patterns.concat(${parentObjectType.staticModuleName}.${syntheticNamePrefix}focusSparqlWherePatterns(${{ filter: variables.filter, focusIdentifier: variables.focusIdentifier, ignoreRdfType: true, preferredLanguages: variables.preferredLanguages, variablePrefix: variables.variablePrefix }}));`);
+patterns = patterns.concat(${parentObjectType.name}.${syntheticNamePrefix}focusSparqlWherePatterns(${{ filter: variables.filter, focusIdentifier: variables.focusIdentifier, ignoreRdfType: true, preferredLanguages: variables.preferredLanguages, variablePrefix: variables.variablePrefix }}));`);
         patternsVariableDeclarationKeyword = "let";
     }
     if (this.fromRdfType.isJust()) {
@@ -75,7 +75,7 @@ if (!parameters?.ignoreRdfType) {
   );
 }`);
     }
-    for (const property of this.ownProperties) {
+    for (const property of this.properties) {
         if (property.recursive) {
             continue;
         }

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

@@ -5,16 +5,9 @@ export function NamedObjectType_fromJsonFunctionDeclaration() {
     if (!this.features.has("json")) {
         return Maybe.empty();
     }
-    if (this.abstract) {
-        return Maybe.empty();
-    }
-    let returnExpression = code `${syntheticNamePrefix}propertiesFromJson(json)`;
-    if (this.declarationType === "class") {
-        returnExpression = code `new ${this.name}(${returnExpression})`;
-    }
     return Maybe.of(code `\
 export function ${syntheticNamePrefix}fromJson(json: ${this.jsonType().name}): ${this.name} {
-  return ${returnExpression};
+  return ${syntheticNamePrefix}create(${syntheticNamePrefix}propertiesFromJson(json));
 }`);
 }
 //# sourceMappingURL=NamedObjectType_fromJsonFunctionDeclaration.js.map

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

@@ -6,21 +6,13 @@ export function NamedObjectType_fromRdfResourceFunctionDeclaration() {
     if (!this.features.has("rdf")) {
         return Maybe.empty();
     }
-    if (this.abstract) {
-        return Maybe.empty();
-    }
-    const statements = [
-        code `let { context, graph, ignoreRdfType = false, objectSet, preferredLanguages } = (options ?? {});`,
-        code `if (!objectSet) { objectSet = new ${syntheticNamePrefix}RdfjsDatasetObjectSet(resource.dataset); }`,
-    ];
-    let propertiesFromRdfExpression = code `${this.staticModuleName}.${syntheticNamePrefix}propertiesFromRdfResource(resource, { context, graph, ignoreRdfType, objectSet, preferredLanguages })`;
-    if (this.declarationType === "class") {
-        propertiesFromRdfExpression = code `${propertiesFromRdfExpression}.map(properties => new ${this.name}(properties))`;
-    }
-    statements.push(code `return ${propertiesFromRdfExpression};`);
     return Maybe.of(code `\
 export const ${syntheticNamePrefix}fromRdfResource: ${snippets.FromRdfResourceFunction}<${this.name}> = (resource, options) => {
-${joinCode(statements)}
+${joinCode([
+        code `let { context, graph, ignoreRdfType = false, objectSet, preferredLanguages } = (options ?? {});`,
+        code `if (!objectSet) { objectSet = new ${syntheticNamePrefix}RdfjsDatasetObjectSet(resource.dataset); }`,
+        code `return ${code `${this.name}.${syntheticNamePrefix}propertiesFromRdfResource(resource, { context, graph, ignoreRdfType, objectSet, preferredLanguages }).map(${syntheticNamePrefix}create)`};`,
+    ])}
 };`);
 }
 //# sourceMappingURL=NamedObjectType_fromRdfResourceFunctionDeclaration.js.map

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

@@ -6,14 +6,11 @@ export function NamedObjectType_fromRdfResourceValuesFunctionDeclaration() {
     if (!this.features.has("rdf")) {
         return Maybe.empty();
     }
-    if (this.abstract) {
-        return Maybe.empty();
-    }
     return Maybe.of(code `\
 export const ${syntheticNamePrefix}fromRdfResourceValues: ${snippets.FromRdfResourceValuesFunction}<${this.name}> = (values, options) => 
   values.chain(
     values => values.chainMap(
-      value => value.toResource().chain(resource => ${this.staticModuleName}.${syntheticNamePrefix}fromRdfResource(resource, options))
+      value => value.toResource().chain(resource => ${this.name}.${syntheticNamePrefix}fromRdfResource(resource, options))
     )
   );`);
 }

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

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

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

@@ -0,0 +1,49 @@
+import { snippets } from "../snippets.js";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+import { code, joinCode } from "../ts-poet-wrapper.js";
+const hasherVariable = code `_hasher`;
+export function NamedObjectType_hashFunctionDeclarations() {
+    if (!this.features.has("hash")) {
+        return [];
+    }
+    const hashOwnShaclPropertiesStatements = this.properties.flatMap((property) => property.kind === "ShaclProperty"
+        ? property.hashStatements({
+            depth: 0,
+            variables: {
+                hasher: hasherVariable,
+                value: property.accessExpression({
+                    variables: { object: this.thisVariable },
+                }),
+            },
+        })
+        : []);
+    const hashShaclPropertiesStatements = [];
+    const hashStatements = [];
+    for (const parentObjectType of this.parentObjectTypes) {
+        hashShaclPropertiesStatements.push(code `${parentObjectType.name}.${syntheticNamePrefix}hashShaclProperties(${this.thisVariable}, ${hasherVariable});`);
+    }
+    hashStatements.push(code `${this.name}.${syntheticNamePrefix}hashShaclProperties(${this.thisVariable}, ${hasherVariable});`);
+    hashShaclPropertiesStatements.push(...hashOwnShaclPropertiesStatements);
+    hashShaclPropertiesStatements.push(code `return ${hasherVariable};`);
+    hashStatements.push(...this.properties
+        .filter((property) => property.kind !== "ShaclProperty")
+        .flatMap((property) => property.hashStatements({
+        depth: 0,
+        variables: {
+            hasher: hasherVariable,
+            value: code `${property.accessExpression({ variables: { object: this.thisVariable } })}`,
+        },
+    })));
+    hashStatements.push(code `return ${hasherVariable};`);
+    return [
+        code `\
+export function ${syntheticNamePrefix}hash<HasherT extends ${snippets.Hasher}>(${this.thisVariable}: ${this.name}, ${hasherVariable}: HasherT): HasherT {
+  ${joinCode(hashStatements)}
+}`,
+        code `\
+export function ${syntheticNamePrefix}hashShaclProperties<HasherT extends ${snippets.Hasher}>(${this.thisVariable}: ${this.name}, ${hasherVariable}: HasherT): HasherT {
+  ${joinCode(hashShaclPropertiesStatements)}
+}`,
+    ];
+}
+//# sourceMappingURL=NamedObjectType_hashFunctionDeclarations.js.map

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

@@ -10,7 +10,7 @@ ${this.comment
             .map((parentObjectType) => parentObjectType.name)
             .join(", ")}`
         : ""} {
-  ${joinCode(this.properties.flatMap((property) => property.declaration.toList()))}
+  ${joinCode(this.properties.map((property) => property.declaration))}
 }`;
 }
 //# sourceMappingURL=NamedObjectType_interfaceDeclaration.js.map

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

@@ -6,9 +6,6 @@ export function NamedObjectType_jsonParseFunctionDeclaration() {
     if (!this.features.has("json")) {
         return Maybe.empty();
     }
-    if (this.abstract) {
-        return Maybe.empty();
-    }
     return Maybe.of(code `\
 export function parse(json: unknown): ${imports.Either}<Error, ${syntheticNamePrefix}Json> {
   const jsonSafeParseResult = schema().safeParse(json);

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

@@ -16,7 +16,7 @@ export function NamedObjectType_jsonSchemaFunctionDeclaration() {
             .map(({ key, schema }) => code `"${key}": ${schema}`));
     }
     const meta = {
-        id: this.name,
+    // id: this.name,
     };
     this.comment.ifJust((description) => {
         meta["description"] = description;

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

@@ -6,8 +6,8 @@ export function NamedObjectType_jsonTypeAliasDeclaration() {
         return Maybe.empty();
     }
     const members = [];
-    if (this.ownProperties.length > 0) {
-        members.push(code `{ ${joinCode(this.ownProperties.flatMap((property) => property.jsonSignature.toList()), { on: ";" })} }`);
+    if (this.properties.length > 0) {
+        members.push(code `{ ${joinCode(this.properties.flatMap((property) => property.jsonSignature.toList()), { on: ";" })} }`);
     }
     for (const parentObjectType of this.parentObjectTypes) {
         members.push(code `${parentObjectType.jsonType().name}`);

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

@@ -7,8 +7,8 @@ export function NamedObjectType_jsonUiSchemaFunctionDeclaration() {
     }
     const variables = { scopePrefix: code `scopePrefix` };
     const elements = this.parentObjectTypes
-        .map((parentObjectType) => code `${parentObjectType.staticModuleName}.${syntheticNamePrefix}Json.uiSchema({ scopePrefix })`)
-        .concat(this.ownProperties.flatMap((property) => property.jsonUiSchemaElement({ variables }).toList()));
+        .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 {
   const scopePrefix = parameters?.scopePrefix ?? "#";

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`)
-        .concat(this.ownProperties.map((property) => code `${property.name}: ${property.schema}`)), { on: ", " })} } } as const;`;
+        .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_toJsonFunctionDeclaration.js

@@ -0,0 +1,41 @@
+import { Maybe } from "purify-ts";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+import { code, joinCode } from "../ts-poet-wrapper.js";
+export function NamedObjectType_toJsonFunctionDeclaration() {
+    if (!this.features.has("json")) {
+        return Maybe.empty();
+    }
+    const jsonObjectMembers = [];
+    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
+            .toJsonObjectMemberExpression({
+            variables: {
+                value: property.accessExpression({
+                    variables: { object: this.thisVariable },
+                }),
+            },
+        })
+            .toList()));
+    }
+    // 20241220: don't add @type until we're doing JSON-LD
+    // switch (this.toRdfTypes.length) {
+    //   case 0:
+    //     break;
+    //   case 1:
+    //     jsonObjectMembers.push(`"@type": "${this.toRdfTypes[0].value}"`);
+    //     break;
+    //   default:
+    //     jsonObjectMembers.push(
+    //       `"@type": ${JSON.stringify(this.toRdfTypes.map((rdfType) => rdfType.value))}`,
+    //     );
+    //     break;
+    // }
+    return Maybe.of(code `\
+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_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,39 +5,18 @@ 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}.${this.identifierProperty.name});`);
+        statements.push(code `const ${variables.resource} = ${variables.resourceSet}.resource(${this.thisVariable}.${syntheticNamePrefix}identifier());`);
     }
     if (this.toRdfTypes.length > 0) {
         statements.push(code `if (!options?.${variables.ignoreRdfType}) { ${joinCode(this.toRdfTypes.map((toRdfType) => code `${variables.resource}.add(${rdfjsTermExpression(rdf.type, { logger: this.logger })}, ${imports.dataFactory}.namedNode("${toRdfType.value}"), options?.${variables.graph});`), { on: " " })} }`);
@@ -48,13 +27,15 @@ export function NamedObjectType_toRdfResourceFunctionOrMethodDeclaration() {
                 graph: code `options?.${variables.graph}`,
                 resource: variables.resource,
                 resourceSet: variables.resourceSet,
-                value: code `${this.thisVariable}.${property.name}`,
+                value: property.accessExpression({
+                    variables: { object: this.thisVariable },
+                }),
             },
         }));
     }
     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)}
 }`);
 }
@@ -64,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/Property.d.ts

@@ -1,7 +1,6 @@
 import type { Type } from "../Type.js";
 import type { DiscriminantProperty } from "./DiscriminantProperty.js";
-import type { IdentifierPrefixProperty } from "./IdentifierPrefixProperty.js";
 import type { IdentifierProperty } from "./IdentifierProperty.js";
 import type { ShaclProperty } from "./ShaclProperty.js";
-export type Property = IdentifierProperty | IdentifierPrefixProperty | ShaclProperty<Type> | DiscriminantProperty;
+export type Property = IdentifierProperty | ShaclProperty<Type> | DiscriminantProperty;
 //# sourceMappingURL=Property.d.ts.map

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

@@ -22,13 +22,11 @@ export declare class ShaclProperty<TypeT extends Type> extends AbstractProperty<
         recursive: boolean;
     } & ConstructorParameters<typeof AbstractProperty<TypeT>>[0]);
     get constructorParametersSignature(): Maybe<Code>;
-    get declaration(): Maybe<Code>;
-    get equalsFunction(): Maybe<Code>;
+    get declaration(): Code;
     get filterProperty(): Maybe<{
         name: string;
         type: Code;
     }>;
-    get getAccessorDeclaration(): Maybe<Code>;
     get graphqlField(): AbstractProperty<TypeT>["graphqlField"];
     get jsonSchema(): AbstractProperty<TypeT>["jsonSchema"];
     get jsonSignature(): Maybe<Code>;