@shaclmate/compiler 3.0.3 → 4.0.0

package/dist/generators/ts/_ObjectType/ObjectType_rdfFunctionDeclarations.js

@@ -0,0 +1,132 @@
+import { rdf } from "@tpluscode/rdf-ns-builders";
+import { Maybe } from "purify-ts";
+import { imports } from "../imports.js";
+import { rdfjsTermExpression } from "../rdfjsTermExpression.js";
+import { snippets } from "../snippets.js";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+import { code, joinCode } from "../ts-poet-wrapper.js";
+import { ObjectType_toRdfFunctionOrMethodDeclaration } from "./ObjectType_toRdfFunctionOrMethodDeclaration.js";
+function ObjectType_fromRdfFunctionDeclaration() {
+    if (this.abstract) {
+        return Maybe.empty();
+    }
+    const statements = [
+        code `let { context, ignoreRdfType = false, objectSet, preferredLanguages } = (options ?? {});`,
+        code `if (!objectSet) { objectSet = new ${syntheticNamePrefix}RdfjsDatasetObjectSet(resource.dataset); }`,
+    ];
+    let propertiesFromRdfExpression = code `${this.staticModuleName}.${syntheticNamePrefix}propertiesFromRdf({ context, ignoreRdfType, objectSet, preferredLanguages, resource })`;
+    if (this.declarationType === "class") {
+        propertiesFromRdfExpression = code `${propertiesFromRdfExpression}.map(properties => new ${this.name}(properties))`;
+    }
+    statements.push(code `return ${propertiesFromRdfExpression};`);
+    return Maybe.of(code `\
+export function ${syntheticNamePrefix}fromRdf(resource: ${imports.Resource}, options?: ${snippets.FromRdfOptions}): ${imports.Either}<Error, ${this.name}> {
+${joinCode(statements)}
+}`);
+}
+function ObjectType_propertiesFromRdfFunctionDeclaration() {
+    const chains = [];
+    const initializers = [];
+    const propertySignatures = [];
+    const returnType = [];
+    const variables = {
+        context: code `${syntheticNamePrefix}parameters.context`,
+        graph: code `${syntheticNamePrefix}parameters.graph`,
+        ignoreRdfType: code `${syntheticNamePrefix}parameters.ignoreRdfType`,
+        objectSet: code `${syntheticNamePrefix}parameters.objectSet`,
+        preferredLanguages: code `${syntheticNamePrefix}parameters.preferredLanguages`,
+        resource: code `${syntheticNamePrefix}parameters.resource`,
+    };
+    this.parentObjectTypes.forEach((parentObjectType, parentObjectTypeI) => {
+        chains.push({
+            expression: code `${parentObjectType.staticModuleName}.${syntheticNamePrefix}propertiesFromRdf({ ...${syntheticNamePrefix}parameters, ignoreRdfType: true })`,
+            variable: `${syntheticNamePrefix}super${parentObjectTypeI}`,
+        });
+        initializers.push(code `...${syntheticNamePrefix}super${parentObjectTypeI}`);
+        returnType.push(code `${snippets.UnwrapR}<ReturnType<typeof ${parentObjectType.staticModuleName}.${syntheticNamePrefix}propertiesFromRdf>>`);
+    });
+    this.fromRdfType.ifJust((fromRdfType) => {
+        const fromRdfTypeVariable = this.fromRdfTypeVariable.unsafeCoerce();
+        const predicate = rdfjsTermExpression(rdf.type);
+        // Check the expected type and its known subtypes
+        const cases = new Set();
+        cases.add(fromRdfType.value);
+        for (const descendantFromRdfType of this.descendantFromRdfTypes) {
+            cases.add(descendantFromRdfType.value);
+        }
+        chains.push({
+            expression: code `!${variables.ignoreRdfType} ? ${variables.resource}.value(${predicate}, ${{ graph: variables.graph }})
+    .chain(actualRdfType => actualRdfType.toIri())
+    .chain((actualRdfType) => {
+      // Check the expected type and its known subtypes
+      switch (actualRdfType.value) {
+        ${[...cases].map((fromRdfType) => `case "${fromRdfType}":`).join("\n")}
+          return ${imports.Right}(true as const);
+      }
+
+      // Check arbitrary rdfs:subClassOf's of the expected type
+      if (${variables.resource}.isInstanceOf(${fromRdfTypeVariable}, ${{ graph: variables.graph }})) {
+        return ${imports.Right}(true as const);
+      }
+
+      return ${imports.Left}(new Error(\`\${${imports.Resource}.Identifier.toString(${variables.resource}.identifier)} has unexpected RDF type (actual: \${actualRdfType.value}, expected: ${fromRdfType.value})\`));
+    }) : ${imports.Right}(true as const)`,
+            variable: "_rdfTypeCheck",
+        });
+    });
+    const propertyFromRdfVariables = {
+        context: variables.context,
+        graph: variables.graph,
+        preferredLanguages: variables.preferredLanguages,
+        objectSet: variables.objectSet,
+        resource: variables.resource,
+    };
+    for (const property of this.properties) {
+        property
+            .fromRdfExpression({
+            variables: propertyFromRdfVariables,
+        })
+            .ifJust((propertyFromRdfExpression) => {
+            chains.push({
+                expression: propertyFromRdfExpression,
+                variable: property.name,
+            });
+            initializers.push(code `${property.name}`);
+            propertySignatures.push(code `${property.name}: ${property.type.name};`);
+        });
+    }
+    const statements = [];
+    const resultExpression = code `{ ${joinCode(initializers, { on: "," })} }`;
+    if (chains.length === 0) {
+        statements.push(code `return ${imports.Right}(${resultExpression});`);
+    }
+    else {
+        statements.push(code `return ${chains
+            .reverse()
+            .reduce((acc, { expression, variable }, chainI) => code `(${expression}).${chainI === 0 ? "map" : "chain"}(${variable} => ${acc})`, code `(${resultExpression})`)}`);
+    }
+    if (propertySignatures.length > 0) {
+        returnType.splice(0, 0, code `{ ${joinCode(propertySignatures, { on: " " })} }`);
+    }
+    return code `\
+export function ${syntheticNamePrefix}propertiesFromRdf(${syntheticNamePrefix}parameters: ${snippets.PropertiesFromRdfParameters}): ${imports.Either}<Error, ${joinCode(returnType, { on: " & " })}> {
+${joinCode(statements)}
+}`;
+}
+export function ObjectType_rdfFunctionDeclarations() {
+    if (!this.features.has("rdf")) {
+        return [];
+    }
+    return [
+        ...ObjectType_fromRdfFunctionDeclaration.bind(this)().toList(),
+        ObjectType_propertiesFromRdfFunctionDeclaration.bind(this)(),
+        ...ObjectType_toRdfFunctionDeclaration.bind(this)().toList(),
+    ];
+}
+function ObjectType_toRdfFunctionDeclaration() {
+    if (this.declarationType !== "interface") {
+        return Maybe.empty();
+    }
+    return ObjectType_toRdfFunctionOrMethodDeclaration.bind(this)();
+}
+//# sourceMappingURL=ObjectType_rdfFunctionDeclarations.js.map

package/dist/generators/ts/_ObjectType/ObjectType_schemaVariableStatement.d.ts

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

package/dist/generators/ts/_ObjectType/ObjectType_schemaVariableStatement.js

@@ -0,0 +1,10 @@
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+import { code, joinCode } from "../ts-poet-wrapper.js";
+export function ObjectType_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;
+`;
+}
+//# sourceMappingURL=ObjectType_schemaVariableStatement.js.map

package/dist/generators/ts/_ObjectType/ObjectType_sparqlConstructQueryFunctionDeclaration.d.ts

@@ -0,0 +1,6 @@
+import { type Code } from "../ts-poet-wrapper.js";
+export declare function ObjectType_sparqlConstructQueryFunctionDeclaration(this: {
+    readonly filterType: Code;
+    readonly staticModuleName: string;
+}): Code;
+//# sourceMappingURL=ObjectType_sparqlConstructQueryFunctionDeclaration.d.ts.map

package/dist/generators/ts/_ObjectType/ObjectType_sparqlConstructQueryFunctionDeclaration.js

@@ -0,0 +1,12 @@
+import { imports } from "../imports.js";
+import { snippets } from "../snippets.js";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+import { code } from "../ts-poet-wrapper.js";
+export function ObjectType_sparqlConstructQueryFunctionDeclaration() {
+    return code `\
+export function ${syntheticNamePrefix}sparqlConstructQuery(parameters?: { filter?: ${this.filterType}; ignoreRdfType?: boolean; prefixes?: { [prefix: string]: string }; preferredLanguages?: readonly string[]; subject?: ${imports.NamedNode} | ${imports.Variable} } & Omit<${imports.sparqljs}.ConstructQuery, "prefixes" | "queryType" | "type">): ${imports.sparqljs}.ConstructQuery {
+  const { filter, ignoreRdfType, preferredLanguages, subject, ...queryParameters } = parameters ?? {};
+  return { ...queryParameters, prefixes: parameters?.prefixes ?? {}, queryType: "CONSTRUCT", template: (queryParameters.template ?? []).concat(${this.staticModuleName}.${syntheticNamePrefix}sparqlConstructTriples({ filter, focusIdentifier: subject, ignoreRdfType })), type: "query", where: (queryParameters.where ?? []).concat(${snippets.normalizeSparqlWherePatterns}(${this.staticModuleName}.${syntheticNamePrefix}sparqlWherePatterns({ filter, focusIdentifier: subject, ignoreRdfType, preferredLanguages }))) };
+}`;
+}
+//# sourceMappingURL=ObjectType_sparqlConstructQueryFunctionDeclaration.js.map

package/dist/generators/ts/_ObjectType/ObjectType_sparqlConstructQueryStringFunctionDeclaration.d.ts

@@ -0,0 +1,6 @@
+import { type Code } from "../ts-poet-wrapper.js";
+export declare function ObjectType_sparqlConstructQueryStringFunctionDeclaration(this: {
+    readonly filterType: Code;
+    readonly staticModuleName: string;
+}): Code;
+//# sourceMappingURL=ObjectType_sparqlConstructQueryStringFunctionDeclaration.d.ts.map

package/dist/generators/ts/_ObjectType/ObjectType_sparqlConstructQueryStringFunctionDeclaration.js

@@ -0,0 +1,10 @@
+import { imports } from "../imports.js";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+import { code } from "../ts-poet-wrapper.js";
+export function ObjectType_sparqlConstructQueryStringFunctionDeclaration() {
+    return code `\
+export function ${syntheticNamePrefix}sparqlConstructQueryString(parameters?: { filter?: ${this.filterType}; ignoreRdfType?: boolean; preferredLanguages?: readonly string[]; subject?: ${imports.NamedNode} | ${imports.Variable}; variablePrefix?: string; } & Omit<${imports.sparqljs}.ConstructQuery, "prefixes" | "queryType" | "type"> & ${imports.sparqljs}.GeneratorOptions): string {
+  return new ${imports.sparqljs}.Generator(parameters).stringify(${this.staticModuleName}.${syntheticNamePrefix}sparqlConstructQuery(parameters));
+}`;
+}
+//# sourceMappingURL=ObjectType_sparqlConstructQueryStringFunctionDeclaration.js.map

package/dist/generators/ts/_ObjectType/ObjectType_sparqlFunctionDeclarations.d.ts

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

package/dist/generators/ts/_ObjectType/ObjectType_sparqlFunctionDeclarations.js

@@ -0,0 +1,143 @@
+import { rdf, rdfs } from "@tpluscode/rdf-ns-builders";
+import { camelCase } from "change-case";
+import { imports } from "../imports.js";
+import { rdfjsTermExpression } from "../rdfjsTermExpression.js";
+import { snippets } from "../snippets.js";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+import { code, joinCode, literalOf } from "../ts-poet-wrapper.js";
+import { ObjectType_sparqlConstructQueryFunctionDeclaration } from "./ObjectType_sparqlConstructQueryFunctionDeclaration.js";
+import { ObjectType_sparqlConstructQueryStringFunctionDeclaration } from "./ObjectType_sparqlConstructQueryStringFunctionDeclaration.js";
+export function ObjectType_sparqlFunctionDeclarations() {
+    if (!this.features.has("sparql")) {
+        return [];
+    }
+    const variables = {
+        filter: code `parameters?.filter`,
+        preferredLanguages: code `parameters?.preferredLanguages`,
+        focusIdentifier: code `focusIdentifier`,
+        variablePrefix: code `(parameters?.variablePrefix ?? (focusIdentifier.termType === "Variable" ? focusIdentifier.value : ${literalOf(camelCase(this.name))}))`,
+    };
+    const rdfClassVariable = code `${imports.dataFactory}.variable!(\`\${${variables.variablePrefix}}RdfClass\`)`;
+    const rdfTypeVariable = code `${imports.dataFactory}.variable!(\`\${${variables.variablePrefix}}RdfType\`)`;
+    let patternsVariableDeclarationKeyword = "const";
+    let triplesVariableDeclarationKeyword = "const";
+    const sparqlConstructTriplesStatements = [];
+    const sparqlWherePatternsStatements = [];
+    for (const parentObjectType of this.parentObjectTypes) {
+        sparqlConstructTriplesStatements.push(code `triples = triples.concat(${parentObjectType.staticModuleName}.${syntheticNamePrefix}sparqlConstructTriples(${{ focusIdentifier: variables.focusIdentifier, ignoreRdfType: true, variablePrefix: variables.variablePrefix }}));`);
+        triplesVariableDeclarationKeyword = "let";
+        sparqlWherePatternsStatements.push(code `\
+patterns = patterns.concat(${parentObjectType.staticModuleName}.${syntheticNamePrefix}sparqlWherePatterns(${{ filter: variables.filter, focusIdentifier: variables.focusIdentifier, ignoreRdfType: true, variablePrefix: variables.variablePrefix }}));`);
+        patternsVariableDeclarationKeyword = "let";
+    }
+    if (this.fromRdfType.isJust()) {
+        const fromRdfTypeVariables = this.fromRdfTypeVariable
+            .toList()
+            .concat(this.descendantFromRdfTypeVariables);
+        sparqlConstructTriplesStatements.push(code `\
+if (!parameters?.ignoreRdfType) {
+  triples.push(
+    { subject: focusIdentifier, predicate: ${rdfjsTermExpression(rdf.type)}, object: ${rdfTypeVariable} },
+    { subject: ${rdfTypeVariable}, predicate: ${rdfjsTermExpression(rdfs.subClassOf)}, object: ${rdfClassVariable} }
+  );
+}`);
+        sparqlWherePatternsStatements.push(code `const rdfTypeVariable = ${rdfTypeVariable};`, code `\
+if (!parameters?.ignoreRdfType) {
+  patterns.push(
+    ${fromRdfTypeVariables.length > 1
+            ? code `\
+    {
+      type: "values" as const,
+      values: [${joinCode(fromRdfTypeVariables, { on: "," })}].map((identifier) => {
+        const valuePatternRow: ${imports.sparqljs}.ValuePatternRow = {};
+        valuePatternRow[\`?\${${variables.variablePrefix}}FromRdfType\`] = identifier as ${imports.NamedNode};
+        return valuePatternRow;
+      }),
+    },
+    ${snippets.sparqlInstancesOfPattern}({ rdfType: ${imports.dataFactory}.variable!(\`\${${variables.variablePrefix}}FromRdfType\`), subject: focusIdentifier }),`
+            : code `${snippets.sparqlInstancesOfPattern}({ rdfType: ${fromRdfTypeVariables[0]}, subject: focusIdentifier }),`}
+    {
+      triples: [
+        {
+          subject: focusIdentifier,
+          predicate: ${rdfjsTermExpression(rdf.type)},
+          object: rdfTypeVariable
+        }
+      ],
+      type: "bgp" as const
+    },
+    {
+      patterns: [
+        {
+          triples: [
+            {
+              subject: rdfTypeVariable,
+              predicate: {
+                items: [${rdfjsTermExpression(rdfs.subClassOf)}],
+                pathType: "+" as const,
+                type: "path" as const
+              },
+              object: ${rdfClassVariable}
+            }
+          ],
+          type: "bgp" as const
+        }
+      ],
+      type: "optional" as const
+    }
+  );
+}`);
+    }
+    for (const property of this.ownProperties) {
+        if (property.recursive) {
+            continue;
+        }
+        property
+            .sparqlConstructTriplesExpression({
+            variables,
+        })
+            .ifJust((propertyTriples) => {
+            sparqlConstructTriplesStatements.push(code `triples = triples.concat(${propertyTriples});`);
+            triplesVariableDeclarationKeyword = "let";
+        });
+        property
+            .sparqlWherePatternsExpression({ variables })
+            .ifJust(({ condition, patterns }) => {
+            const concatStatement = code `patterns = patterns.concat(${patterns});`;
+            if (condition) {
+                sparqlWherePatternsStatements.push(code `if (${condition}) { ${concatStatement} }`);
+            }
+            else {
+                sparqlWherePatternsStatements.push(concatStatement);
+            }
+            patternsVariableDeclarationKeyword = "let";
+        });
+    }
+    return [
+        ObjectType_sparqlConstructQueryFunctionDeclaration.bind(this)(),
+        ObjectType_sparqlConstructQueryStringFunctionDeclaration.bind(this)(),
+        code `\
+export function ${syntheticNamePrefix}sparqlConstructTriples(${sparqlConstructTriplesStatements.length === 0 ? "_" : ""}parameters?: { filter?: ${this.filterType}; focusIdentifier?: ${imports.NamedNode} | ${imports.Variable}; ignoreRdfType?: boolean;  variablePrefix?: string }): readonly ${imports.sparqljs}.Triple[] {
+${sparqlConstructTriplesStatements.length > 0
+            ? joinCode([
+                code `const focusIdentifier = parameters?.focusIdentifier ?? ${imports.dataFactory}.variable!(${literalOf(camelCase(this.name))});`,
+                code `${triplesVariableDeclarationKeyword} triples: ${imports.sparqljs}.Triple[] = [];`,
+                ...sparqlConstructTriplesStatements,
+                code `return triples;`,
+            ])
+            : "return [];"}
+}`,
+        code `\
+export function ${syntheticNamePrefix}sparqlWherePatterns(${sparqlWherePatternsStatements.length === 0 ? "_" : ""}parameters?: { filter?: ${this.filterType}; focusIdentifier?: ${imports.NamedNode} | ${imports.Variable}; ignoreRdfType?: boolean; preferredLanguages?: readonly string[]; variablePrefix?: string }): readonly ${snippets.SparqlPattern}[] {
+${sparqlWherePatternsStatements.length > 0
+            ? joinCode([
+                code `${patternsVariableDeclarationKeyword} patterns: ${snippets.SparqlPattern}[] = [];`,
+                code `const focusIdentifier = parameters?.focusIdentifier ?? ${imports.dataFactory}.variable!(${literalOf(camelCase(this.name))});`,
+                ...sparqlWherePatternsStatements,
+                code `return patterns;`,
+            ])
+            : "return [];"}
+}`,
+    ];
+}
+//# sourceMappingURL=ObjectType_sparqlFunctionDeclarations.js.map

package/dist/generators/ts/_ObjectType/ObjectType_toJsonFunctionOrMethodDeclaration.d.ts

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

package/dist/generators/ts/_ObjectType/{toJsonFunctionOrMethodDeclaration.js → ObjectType_toJsonFunctionOrMethodDeclaration.js}

@@ -1,6 +1,7 @@
 import { Maybe } from "purify-ts";
 import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
-export function toJsonFunctionOrMethodDeclaration() {
+import { code, joinCode } from "../ts-poet-wrapper.js";
+export function ObjectType_toJsonFunctionOrMethodDeclaration() {
     if (!this.features.has("json")) {
         return Maybe.empty();
     }
@@ -11,26 +12,29 @@ export function toJsonFunctionOrMethodDeclaration() {
     }
     const jsonObjectMembers = [];
     const parameters = [];
+    let preamble;
     switch (this.declarationType) {
         case "class":
             if (this.parentObjectTypes.length > 0) {
-                jsonObjectMembers.push(`...super.${syntheticNamePrefix}toJson()`);
+                jsonObjectMembers.push(code `...super.${syntheticNamePrefix}toJson()`);
+                preamble = "override ";
+            }
+            else {
+                preamble = "";
             }
             break;
         case "interface":
             for (const parentObjectType of this.parentObjectTypes) {
-                jsonObjectMembers.push(`...${parentObjectType.staticModuleName}.${syntheticNamePrefix}toJson(${this.thisVariable})`);
+                jsonObjectMembers.push(code `...${parentObjectType.staticModuleName}.${syntheticNamePrefix}toJson(${this.thisVariable})`);
             }
-            parameters.push({
-                name: this.thisVariable,
-                type: this.name,
-            });
+            parameters.push(code `${this.thisVariable}: ${this.name}`);
+            preamble = "export function ";
             break;
     }
     if (this.ownProperties.length > 0) {
         jsonObjectMembers.push(...this.ownProperties.flatMap((property) => property
-            .toJsonObjectMember({
-            variables: { value: `${this.thisVariable}.${property.name}` },
+            .toJsonObjectMemberExpression({
+            variables: { value: code `${this.thisVariable}.${property.name}` },
         })
             .toList()));
     }
@@ -47,13 +51,9 @@ export function toJsonFunctionOrMethodDeclaration() {
     //     );
     //     break;
     // }
-    return Maybe.of({
-        name: `${syntheticNamePrefix}toJson`,
-        parameters,
-        returnType: this.jsonName.toString(),
-        statements: [
-            `return JSON.parse(JSON.stringify({ ${jsonObjectMembers.join(",")} } satisfies ${this.jsonName}));`,
-        ],
-    });
+    return Maybe.of(code `\
+${preamble}${syntheticNamePrefix}toJson(${joinCode(parameters, { on: ", " })}): ${this.jsonType().name} {
+  return JSON.parse(JSON.stringify({ ${joinCode(jsonObjectMembers, { on: "," })} } satisfies ${this.jsonType().name}));
+}`);
 }
-//# sourceMappingURL=toJsonFunctionOrMethodDeclaration.js.map
+//# sourceMappingURL=ObjectType_toJsonFunctionOrMethodDeclaration.js.map

package/dist/generators/ts/_ObjectType/ObjectType_toRdfFunctionOrMethodDeclaration.d.ts

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

package/dist/generators/ts/_ObjectType/ObjectType_toRdfFunctionOrMethodDeclaration.js

@@ -0,0 +1,65 @@
+import { rdf } from "@tpluscode/rdf-ns-builders";
+import { Maybe } from "purify-ts";
+import { imports } from "../imports.js";
+import { rdfjsTermExpression } from "../rdfjsTermExpression.js";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+import { code, joinCode } from "../ts-poet-wrapper.js";
+export function ObjectType_toRdfFunctionOrMethodDeclaration() {
+    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?: { ${variables.ignoreRdfType}?: boolean; ${variables.graph}?: Exclude<${imports.Quad_Graph}, ${imports.Variable}>, ${variables.resourceSet}?: ${imports.ResourceSet} }`);
+    const statements = [
+        code `const ${variables.resourceSet} = options?.${variables.resourceSet} ?? new ${imports.ResourceSet}(${imports.datasetFactory}.dataset(), { dataFactory: ${imports.dataFactory} });`,
+    ];
+    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}toRdf(${superToRdfOptions})`;
+                break;
+            case "interface":
+                superToRdfCall = code `${this.parentObjectTypes[0].staticModuleName}.${syntheticNamePrefix}toRdf(${this.thisVariable}, ${superToRdfOptions})`;
+                break;
+        }
+        statements.push(code `const ${variables.resource} = ${superToRdfCall};`);
+    }
+    else {
+        statements.push(code `const ${variables.resource} = ${variables.resourceSet}.resource(${this.thisVariable}.${this.identifierProperty.name});`);
+    }
+    if (this.toRdfTypes.length > 0) {
+        statements.push(code `if (!options?.${variables.ignoreRdfType}) { ${joinCode(this.toRdfTypes.map((toRdfType) => code `${variables.resource}.add(${rdfjsTermExpression(rdf.type)}, ${imports.dataFactory}.namedNode("${toRdfType.value}"), options?.${variables.graph});`), { on: " " })} }`);
+    }
+    for (const property of this.properties) {
+        statements.push(...property.toRdfStatements({
+            variables: {
+                ...variables,
+                graph: code `options?.${variables.graph}`,
+                value: code `${this.thisVariable}.${property.name}`,
+            },
+        }));
+    }
+    statements.push(code `return ${variables.resource};`);
+    return Maybe.of(code `\
+${preamble}${syntheticNamePrefix}toRdf(${joinCode(parameters, { on: "," })}): ${this.toRdfjsResourceType} {
+  ${joinCode(statements)}
+}`);
+}
+const variables = {
+    ignoreRdfType: code `ignoreRdfType`,
+    graph: code `graph`,
+    resource: code `resource`,
+    resourceSet: code `resourceSet`,
+};
+//# sourceMappingURL=ObjectType_toRdfFunctionOrMethodDeclaration.js.map

package/dist/generators/ts/_ObjectType/Property.d.ts

@@ -1,170 +1,7 @@
-import type { Maybe } from "purify-ts";
-import { type GetAccessorDeclarationStructure, type OptionalKind, type PropertyDeclarationStructure, type PropertySignatureStructure, Scope } from "ts-morph";
-import type { PropertyVisibility } from "../../../enums/index.js";
-import type { Import } from "../Import.js";
-import type { ObjectType } from "../ObjectType.js";
 import type { Type } from "../Type.js";
-export declare abstract class Property<TypeT extends Pick<Type, "mutable" | "name">> {
-    /**
-     * Optional property to include in the parameters object of a class constructor.
-     */
-    abstract readonly constructorParametersPropertySignature: Maybe<OptionalKind<PropertySignatureStructure>>;
-    /**
-     * Function declaration that takes two values of the property and compares them, returning an $EqualsResult.
-     */
-    abstract readonly equalsFunction: Maybe<string>;
-    /**
-     * Optional get accessor to include in a class declaration of the object type.
-     */
-    abstract readonly getAccessorDeclaration: Maybe<OptionalKind<GetAccessorDeclarationStructure>>;
-    /**
-     * GraphQL.js field definition.
-     */
-    abstract readonly graphqlField: Maybe<{
-        args: Maybe<Record<string, {
-            type: string;
-        }>>;
-        description: Maybe<string>;
-        name: string;
-        resolve: string;
-        type: string;
-    }>;
-    /**
-     * Signature of the property when serialized to JSON (the type of toJsonObjectMember).
-     */
-    abstract readonly jsonPropertySignature: Maybe<OptionalKind<PropertySignatureStructure>>;
-    /**
-     * Is the property reassignable?
-     */
-    abstract readonly mutable: boolean;
-    /**
-     * TypeScript identifier-safe name of the property.
-     */
-    readonly name: string;
-    /**
-     * Optional property declaration to include in a class declaration of the object type.
-     */
-    abstract readonly propertyDeclaration: Maybe<OptionalKind<PropertyDeclarationStructure>>;
-    /**
-     * Signature of the property in an interface version of the object.
-     */
-    abstract readonly propertySignature: Maybe<OptionalKind<PropertySignatureStructure>>;
-    /**
-     * Is the property's type the ObjectType or does its type indirectly reference the ObjectType?
-     */
-    abstract readonly recursive: boolean;
-    /**
-     * Property type
-  .   */
-    readonly type: TypeT;
-    /**
-     * Property visibility: private, protected, public.
-     */
-    readonly visibility: PropertyVisibility;
-    protected readonly objectType: ObjectType;
-    constructor({ name, objectType, type, visibility, }: {
-        name: string;
-        objectType: ObjectType;
-        type: TypeT;
-        visibility: PropertyVisibility;
-    });
-    /**
-     * Imports this property requires when declared in an object.
-     */
-    abstract get declarationImports(): readonly Import[];
-    protected static visibilityToScope(visibility: PropertyVisibility): Scope | undefined;
-    /**
-     * Statements to assign the parameter of described by constructorParametersPropertySignature to a class or interface member.
-     */
-    abstract constructorStatements(parameters: {
-        variables: {
-            parameter: string;
-            parameters: string;
-        };
-    }): readonly string[];
-    /**
-     * Statements to deserialize JSON for this property (as described by toJsonObjectMember) to a typed value of the property.
-     */
-    abstract fromJsonStatements(parameters: {
-        variables: {
-            jsonObject: string;
-        };
-    }): readonly string[];
-    /**
-     * Statements to deserialize this property on the given rdfjsResource.Resource to a typed value of the property.
-     */
-    abstract fromRdfStatements(parameters: {
-        variables: {
-            context: string;
-            objectSet: string;
-            preferredLanguages: string;
-            resource: string;
-        };
-    }): readonly string[];
-    /**
-     * Statements to hash this property using a hasher instance.
-     */
-    abstract hashStatements(parameters: Parameters<Type["hashStatements"]>[0]): readonly string[];
-    /**
-     * Element object (usually a control https://jsonforms.io/docs/uischema/controls) for a JSON Forms UI schema.
-     */
-    abstract jsonUiSchemaElement(parameters: {
-        variables: {
-            scopePrefix: string;
-        };
-    }): Maybe<string>;
-    /**
-     * zod Object key: schema pair on the property serialized by toJsonObjectMember.
-     */
-    abstract jsonZodSchema(parameters: {
-        variables: {
-            zod: string;
-        };
-    }): Maybe<{
-        readonly key: string;
-        readonly schema: string;
-    }>;
-    /**
-     * Reusable function, type, and other declarations that are not particular to this property but that property-specific code
-     * relies on. For example, the equals function/method of ObjectType has a custom return type that's the same across all
-     * ObjectType's. Instead of re-declaring the return type anonymously on every equals function, declare a named type
-     * as a snippet and reference it.
-     *
-     * The generator deduplicates snippet declarations across all types before adding them to the source.
-     */
-    abstract snippetDeclarations(parameters: Parameters<Type["snippetDeclarations"]>[0]): readonly string[];
-    /**
-     * An array of SPARQL.js CONSTRUCT template triples for this property as strings (so they can incorporate runtime calls).
-     */
-    abstract sparqlConstructTemplateTriples(parameters: {
-        variables: {
-            subject: string;
-            variablePrefix: string;
-        };
-    }): readonly string[];
-    /**
-     * An array of SPARQL.js where patterns for this property as strings (so they can incorporate runtime calls).
-     */
-    abstract sparqlWherePatterns(parameters: {
-        variables: {
-            preferredLanguages: string;
-            subject: string;
-            variablePrefix: string;
-        };
-    }): readonly string[];
-    /**
-     * property: expression to serialize a property to a JSON object member.
-     */
-    abstract toJsonObjectMember(parameters: {
-        variables: {
-            value: string;
-        };
-    }): Maybe<string>;
-    /**
-     * Statements to serialize this property to an RDF resource.
-     */
-    abstract toRdfStatements(parameters: {
-        variables: Omit<Parameters<Type["toRdfExpression"]>[0]["variables"], "predicate">;
-    }): readonly string[];
-}
+import type { IdentifierPrefixProperty } from "./IdentifierPrefixProperty.js";
+import type { IdentifierProperty } from "./IdentifierProperty.js";
+import type { ShaclProperty } from "./ShaclProperty.js";
+import type { TypeDiscriminantProperty } from "./TypeDiscriminantProperty.js";
+export type Property = IdentifierProperty | IdentifierPrefixProperty | ShaclProperty<Type> | TypeDiscriminantProperty;
 //# sourceMappingURL=Property.d.ts.map