@shaclmate/compiler 4.0.8 → 4.0.9

package/dist/generators/ts/_ObjectType/{ObjectType_sparqlConstructTriplesFunctionDeclaration.js → ObjectType_focusSparqlConstructTriplesFunctionDeclaration.js}

@@ -2,6 +2,7 @@ import { rdf, rdfs } 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";
 const variables = {
@@ -9,7 +10,7 @@ const variables = {
     focusIdentifier: code `parameters.focusIdentifier`,
     variablePrefix: code `parameters.variablePrefix`,
 };
-export function ObjectType_sparqlConstructTriplesFunctionDeclaration() {
+export function ObjectType_focusSparqlConstructTriplesFunctionDeclaration() {
     if (!this.features.has("sparql")) {
         return Maybe.empty();
     }
@@ -18,7 +19,7 @@ export function ObjectType_sparqlConstructTriplesFunctionDeclaration() {
     let triplesVariableDeclarationKeyword = "const";
     const statements = [];
     for (const parentObjectType of this.parentObjectTypes) {
-        statements.push(code `triples = triples.concat(${parentObjectType.staticModuleName}.${syntheticNamePrefix}sparqlConstructTriples(${{ filter: variables.filter, focusIdentifier: variables.focusIdentifier, ignoreRdfType: true, variablePrefix: variables.variablePrefix }}));`);
+        statements.push(code `triples = triples.concat(${parentObjectType.staticModuleName}.${syntheticNamePrefix}focusSparqlConstructTriples(${{ filter: variables.filter, focusIdentifier: variables.focusIdentifier, ignoreRdfType: true, variablePrefix: variables.variablePrefix }}));`);
         triplesVariableDeclarationKeyword = "let";
     }
     if (this.fromRdfType.isJust()) {
@@ -44,7 +45,7 @@ if (!parameters?.ignoreRdfType) {
         });
     }
     return Maybe.of(code `\
-export function ${syntheticNamePrefix}sparqlConstructTriples(${statements.length === 0 ? "_" : ""}parameters: { filter: ${this.filterType} | undefined; focusIdentifier: ${imports.NamedNode} | ${imports.Variable}; ignoreRdfType: boolean;  variablePrefix: string }): readonly ${imports.sparqljs}.Triple[] {
+export const ${syntheticNamePrefix}focusSparqlConstructTriples: ${snippets.FocusSparqlConstructTriplesFunction}<${this.filterType}> = (${statements.length === 0 ? "_" : ""}parameters) => {
 ${statements.length > 0
         ? joinCode([
             code `${triplesVariableDeclarationKeyword} triples: ${imports.sparqljs}.Triple[] = [];`,
@@ -52,6 +53,6 @@ ${statements.length > 0
             code `return triples;`,
         ])
         : "return [];"}
-}`);
+};`);
 }
-//# sourceMappingURL=ObjectType_sparqlConstructTriplesFunctionDeclaration.js.map
+//# sourceMappingURL=ObjectType_focusSparqlConstructTriplesFunctionDeclaration.js.map

package/dist/generators/ts/_ObjectType/ObjectType_focusSparqlWherePatternsFunctionDeclaration.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_focusSparqlWherePatternsFunctionDeclaration(this: ObjectType): Maybe<Code>;
+//# sourceMappingURL=ObjectType_focusSparqlWherePatternsFunctionDeclaration.d.ts.map

package/dist/generators/ts/_ObjectType/{ObjectType_sparqlWherePatternsFunctionDeclarations.js → ObjectType_focusSparqlWherePatternsFunctionDeclaration.js}

@@ -11,7 +11,7 @@ const variables = {
     focusIdentifier: code `parameters.focusIdentifier`,
     variablePrefix: code `parameters.variablePrefix`,
 };
-export function ObjectType_sparqlWherePatternsFunctionDeclaration() {
+export function ObjectType_focusSparqlWherePatternsFunctionDeclaration() {
     if (!this.features.has("sparql")) {
         return Maybe.empty();
     }
@@ -21,7 +21,7 @@ export function ObjectType_sparqlWherePatternsFunctionDeclaration() {
     const statements = [];
     for (const parentObjectType of this.parentObjectTypes) {
         statements.push(code `\
-patterns = patterns.concat(${parentObjectType.staticModuleName}.${syntheticNamePrefix}sparqlWherePatterns(${{ filter: variables.filter, focusIdentifier: variables.focusIdentifier, ignoreRdfType: true, preferredLanguages: variables.preferredLanguages, variablePrefix: variables.variablePrefix }}));`);
+patterns = patterns.concat(${parentObjectType.staticModuleName}.${syntheticNamePrefix}focusSparqlWherePatterns(${{ filter: variables.filter, focusIdentifier: variables.focusIdentifier, ignoreRdfType: true, preferredLanguages: variables.preferredLanguages, variablePrefix: variables.variablePrefix }}));`);
         patternsVariableDeclarationKeyword = "let";
     }
     if (this.fromRdfType.isJust()) {
@@ -93,7 +93,7 @@ if (!parameters?.ignoreRdfType) {
         });
     }
     return Maybe.of(code `\
-export function ${syntheticNamePrefix}sparqlWherePatterns(${statements.length === 0 ? "_" : ""}parameters: { filter: ${this.filterType} | undefined; focusIdentifier: ${imports.NamedNode} | ${imports.Variable}; ignoreRdfType: boolean; preferredLanguages: readonly string[] | undefined; variablePrefix: string }): readonly ${snippets.SparqlPattern}[] {
+export const ${syntheticNamePrefix}focusSparqlWherePatterns: ${snippets.FocusSparqlWherePatternsFunction}<${this.filterType}> = (${statements.length === 0 ? "_" : ""}parameters) => {
 ${statements.length > 0
         ? joinCode([
             code `${patternsVariableDeclarationKeyword} patterns: ${snippets.SparqlPattern}[] = [];`,
@@ -101,6 +101,6 @@ ${statements.length > 0
             code `return patterns;`,
         ])
         : "return [];"}
-}`);
+};`);
 }
-//# sourceMappingURL=ObjectType_sparqlWherePatternsFunctionDeclarations.js.map
+//# sourceMappingURL=ObjectType_focusSparqlWherePatternsFunctionDeclaration.js.map

package/dist/generators/ts/_ObjectType/ObjectType_fromJsonFunctionDeclaration.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_fromJsonFunctionDeclaration(this: ObjectType): Maybe<Code>;
+//# sourceMappingURL=ObjectType_fromJsonFunctionDeclaration.d.ts.map

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

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

package/dist/generators/ts/_ObjectType/ObjectType_fromRdfResourceFunctionDeclaration.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_fromRdfResourceFunctionDeclaration(this: ObjectType): Maybe<Code>;
+//# sourceMappingURL=ObjectType_fromRdfResourceFunctionDeclaration.d.ts.map

package/dist/generators/ts/_ObjectType/{ObjectType_fromRdfFunctionDeclaration.js → ObjectType_fromRdfResourceFunctionDeclaration.js}

@@ -1,9 +1,8 @@
 import { Maybe } from "purify-ts";
-import { imports } from "../imports.js";
 import { snippets } from "../snippets.js";
 import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code, joinCode } from "../ts-poet-wrapper.js";
-export function ObjectType_fromRdfFunctionDeclaration() {
+export function ObjectType_fromRdfResourceFunctionDeclaration() {
     if (!this.features.has("rdf")) {
         return Maybe.empty();
     }
@@ -11,17 +10,17 @@ export function ObjectType_fromRdfFunctionDeclaration() {
         return Maybe.empty();
     }
     const statements = [
-        code `let { context, ignoreRdfType = false, objectSet, preferredLanguages } = (options ?? {});`,
+        code `let { context, graph, 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 })`;
+    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 function ${syntheticNamePrefix}fromRdf(resource: ${imports.Resource}, options?: ${snippets.FromRdfOptions}): ${imports.Either}<Error, ${this.name}> {
+export const ${syntheticNamePrefix}fromRdfResource: ${snippets.FromRdfResourceFunction}<${this.name}> = (resource, options) => {
 ${joinCode(statements)}
-}`);
+};`);
 }
-//# sourceMappingURL=ObjectType_fromRdfFunctionDeclaration.js.map
+//# sourceMappingURL=ObjectType_fromRdfResourceFunctionDeclaration.js.map

package/dist/generators/ts/_ObjectType/ObjectType_fromRdfResourceValuesFunctionDeclaration.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_fromRdfResourceValuesFunctionDeclaration(this: ObjectType): Maybe<Code>;
+//# sourceMappingURL=ObjectType_fromRdfResourceValuesFunctionDeclaration.d.ts.map

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

@@ -0,0 +1,20 @@
+import { Maybe } from "purify-ts";
+import { snippets } from "../snippets.js";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+import { code } from "../ts-poet-wrapper.js";
+export function ObjectType_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))
+    )
+  );`);
+}
+//# sourceMappingURL=ObjectType_fromRdfResourceValuesFunctionDeclaration.js.map

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

@@ -4,8 +4,8 @@ export function ObjectType_isTypeFunctionDeclaration() {
     return code `\
 export function is${this.name}(object: ${syntheticNamePrefix}Object): object is ${this.name} {
   switch (object.${this._discriminantProperty.name}) {
-    ${this._discriminantProperty.descendantValues
-        .concat(this._discriminantProperty.ownValues)
+    ${this._discriminantProperty.type.descendantValues
+        .concat(this._discriminantProperty.type.ownValues)
         .map((value) => `case "${value}":`)
         .join("\n")} return true; default: return false;
   }

package/dist/generators/ts/_ObjectType/ObjectType_parseJsonFunctionDeclaration.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_parseJsonFunctionDeclaration(this: ObjectType): Maybe<Code>;
+//# sourceMappingURL=ObjectType_parseJsonFunctionDeclaration.d.ts.map

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

@@ -0,0 +1,19 @@
+import { Maybe } from "purify-ts";
+import { imports } from "../imports.js";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+import { code } from "../ts-poet-wrapper.js";
+export function ObjectType_parseJsonFunctionDeclaration() {
+    if (!this.features.has("json")) {
+        return Maybe.empty();
+    }
+    if (this.abstract) {
+        return Maybe.empty();
+    }
+    return Maybe.of(code `\
+export function ${syntheticNamePrefix}parseJson(json: unknown): ${imports.Either}<Error, ${this.name}> {
+  const ${syntheticNamePrefix}jsonSafeParseResult = ${syntheticNamePrefix}jsonZodSchema().safeParse(json);
+  if (!${syntheticNamePrefix}jsonSafeParseResult.success) { return ${imports.Left}(${syntheticNamePrefix}jsonSafeParseResult.error); }
+  return ${imports.Right}(${syntheticNamePrefix}fromJson(${syntheticNamePrefix}jsonSafeParseResult.data));
+}`);
+}
+//# sourceMappingURL=ObjectType_parseJsonFunctionDeclaration.js.map

package/dist/generators/ts/_ObjectType/ObjectType_propertiesFromJsonFunctionDeclaration.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_propertiesFromJsonFunctionDeclaration(this: ObjectType): Maybe<Code>;
+//# sourceMappingURL=ObjectType_propertiesFromJsonFunctionDeclaration.d.ts.map

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

@@ -0,0 +1,38 @@
+import { Maybe } from "purify-ts";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+import { code, joinCode } from "../ts-poet-wrapper.js";
+const variables = {
+    jsonObject: code `${syntheticNamePrefix}json`,
+};
+export function ObjectType_propertiesFromJsonFunctionDeclaration() {
+    if (!this.features.has("json")) {
+        return Maybe.empty();
+    }
+    const initializers = [];
+    const statements = [];
+    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>`);
+    });
+    for (const property of this.properties) {
+        const propertyFromJsonStatements = property.fromJsonStatements({
+            variables,
+        });
+        if (propertyFromJsonStatements.length > 0) {
+            propertyReturnTypeSignatures.push(code `${property.name}: ${property.type.name};`);
+            initializers.push(code `${property.name}`);
+            statements.push(...propertyFromJsonStatements);
+        }
+    }
+    statements.push(code `return { ${joinCode(initializers, { on: ", " })} };`);
+    if (propertyReturnTypeSignatures.length > 0) {
+        returnType.splice(0, 0, code `{ ${joinCode(propertyReturnTypeSignatures, { on: " " })} }`);
+    }
+    return Maybe.of(code `\
+export function ${syntheticNamePrefix}propertiesFromJson(${variables.jsonObject}: ${this.jsonType().name}): ${joinCode(returnType, { on: " & " })} {
+${joinCode(statements)}
+}`);
+}
+//# sourceMappingURL=ObjectType_propertiesFromJsonFunctionDeclaration.js.map

package/dist/generators/ts/_ObjectType/ObjectType_propertiesFromRdfResourceFunctionDeclaration.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_propertiesFromRdfResourceFunctionDeclaration(this: ObjectType): Maybe<Code>;
+//# sourceMappingURL=ObjectType_propertiesFromRdfResourceFunctionDeclaration.d.ts.map

package/dist/generators/ts/_ObjectType/{ObjectType_propertiesFromRdfFunctionDeclaration.js → ObjectType_propertiesFromRdfResourceFunctionDeclaration.js}

@@ -5,7 +5,16 @@ 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 ObjectType_propertiesFromRdfFunctionDeclaration() {
+const optionsVariable = `_${syntheticNamePrefix}options`;
+const variables = {
+    context: code `${optionsVariable}.context`,
+    graph: code `${optionsVariable}.graph`,
+    ignoreRdfType: code `${optionsVariable}.ignoreRdfType`,
+    objectSet: code `${optionsVariable}.objectSet`,
+    preferredLanguages: code `${optionsVariable}.preferredLanguages`,
+    resource: code `${syntheticNamePrefix}resource`,
+};
+export function ObjectType_propertiesFromRdfResourceFunctionDeclaration() {
     if (!this.features.has("rdf")) {
         return Maybe.empty();
     }
@@ -13,21 +22,13 @@ export function ObjectType_propertiesFromRdfFunctionDeclaration() {
     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 })`,
+            expression: code `${parentObjectType.staticModuleName}.${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}propertiesFromRdf>>`);
+        returnType.push(code `${snippets.UnwrapR}<ReturnType<typeof ${parentObjectType.staticModuleName}.${syntheticNamePrefix}propertiesFromRdfResource>>`);
     });
     this.fromRdfType.ifJust((fromRdfType) => {
         const fromRdfTypeVariable = this.fromRdfTypeVariable.unsafeCoerce();
@@ -67,7 +68,7 @@ export function ObjectType_propertiesFromRdfFunctionDeclaration() {
     };
     for (const property of this.properties) {
         property
-            .fromRdfExpression({
+            .fromRdfResourceValuesExpression({
             variables: propertyFromRdfVariables,
         })
             .ifJust((propertyFromRdfExpression) => {
@@ -93,8 +94,8 @@ export function ObjectType_propertiesFromRdfFunctionDeclaration() {
         returnType.splice(0, 0, code `{ ${joinCode(propertySignatures, { on: " " })} }`);
     }
     return Maybe.of(code `\
-export function ${syntheticNamePrefix}propertiesFromRdf(${syntheticNamePrefix}parameters: ${snippets.PropertiesFromRdfParameters}): ${imports.Either}<Error, ${joinCode(returnType, { on: " & " })}> {
+export const ${syntheticNamePrefix}propertiesFromRdfResource: ${snippets.PropertiesFromRdfResourceFunction}<${joinCode(returnType, { on: " & " })}> = (${syntheticNamePrefix}resource, ${optionsVariable}) => {
 ${joinCode(statements)}
-}`);
+};`);
 }
-//# sourceMappingURL=ObjectType_propertiesFromRdfFunctionDeclaration.js.map
+//# sourceMappingURL=ObjectType_propertiesFromRdfResourceFunctionDeclaration.js.map

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

@@ -4,7 +4,6 @@ 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;
-`;
+        .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.js

@@ -17,7 +17,7 @@ export function ${syntheticNamePrefix}sparqlConstructQuery({ filter, ignoreRdfTy
     prefixes: prefixes ?? {},
     queryType: "CONSTRUCT",
     template: (queryParameters.template ?? []).concat(
-      ${this.staticModuleName}.${syntheticNamePrefix}sparqlConstructTriples({
+      ${this.staticModuleName}.${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}sparqlWherePatterns({
+        ${this.staticModuleName}.${syntheticNamePrefix}focusSparqlWherePatterns({
           filter,
           focusIdentifier: subject,
           ignoreRdfType: !!ignoreRdfType,

package/dist/generators/ts/_ObjectType/ObjectType_toRdfResourceFunctionOrMethodDeclaration.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_toRdfResourceFunctionOrMethodDeclaration(this: ObjectType): Maybe<Code>;
+//# sourceMappingURL=ObjectType_toRdfResourceFunctionOrMethodDeclaration.d.ts.map

package/dist/generators/ts/_ObjectType/{ObjectType_toRdfFunctionOrMethodDeclaration.js → ObjectType_toRdfResourceFunctionOrMethodDeclaration.js}

@@ -2,9 +2,10 @@ 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";
-export function ObjectType_toRdfFunctionOrMethodDeclaration() {
+export function ObjectType_toRdfResourceFunctionOrMethodDeclaration() {
     if (!this.features.has("rdf")) {
         return Maybe.empty();
     }
@@ -17,7 +18,7 @@ export function ObjectType_toRdfFunctionOrMethodDeclaration() {
     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} }`);
+    parameters.push(code `options?: Parameters<${snippets.ToRdfResourceFunction}<${this.name}>>[1]`);
     const statements = [
         code `const ${variables.resourceSet} = options?.${variables.resourceSet} ?? new ${imports.ResourceSet}(${imports.datasetFactory}.dataset(), { dataFactory: ${imports.dataFactory} });`,
     ];
@@ -27,10 +28,10 @@ export function ObjectType_toRdfFunctionOrMethodDeclaration() {
         switch (this.declarationType) {
             case "class":
                 preamble = "override ";
-                superToRdfCall = code `super.${syntheticNamePrefix}toRdf(${superToRdfOptions})`;
+                superToRdfCall = code `super.${syntheticNamePrefix}toRdfResource(${superToRdfOptions})`;
                 break;
             case "interface":
-                superToRdfCall = code `${this.parentObjectTypes[0].staticModuleName}.${syntheticNamePrefix}toRdf(${this.thisVariable}, ${superToRdfOptions})`;
+                superToRdfCall = code `${this.parentObjectTypes[0].staticModuleName}.${syntheticNamePrefix}toRdfResource(${this.thisVariable}, ${superToRdfOptions})`;
                 break;
         }
         statements.push(code `const ${variables.resource} = ${superToRdfCall};`);
@@ -42,17 +43,18 @@ export function ObjectType_toRdfFunctionOrMethodDeclaration() {
         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({
+        statements.push(...property.toRdfRdfResourceValuesStatements({
             variables: {
-                ...variables,
                 graph: code `options?.${variables.graph}`,
+                resource: variables.resource,
+                resourceSet: variables.resourceSet,
                 value: code `${this.thisVariable}.${property.name}`,
             },
         }));
     }
     statements.push(code `return ${variables.resource};`);
     return Maybe.of(code `\
-${preamble}${syntheticNamePrefix}toRdf(${joinCode(parameters, { on: "," })}): ${this.toRdfjsResourceType} {
+${preamble}${syntheticNamePrefix}toRdfResource(${joinCode(parameters, { on: "," })}): ${this.toRdfjsResourceType} {
   ${joinCode(statements)}
 }`);
 }
@@ -62,4 +64,4 @@ const variables = {
     resource: code `resource`,
     resourceSet: code `resourceSet`,
 };
-//# sourceMappingURL=ObjectType_toRdfFunctionOrMethodDeclaration.js.map
+//# sourceMappingURL=ObjectType_toRdfResourceFunctionOrMethodDeclaration.js.map

package/dist/generators/ts/_ObjectType/ObjectType_valueSparqlConstructTriplesFunctionDeclaration.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_valueSparqlConstructTriplesFunctionDeclaration(this: ObjectType): Maybe<Code>;
+//# sourceMappingURL=ObjectType_valueSparqlConstructTriplesFunctionDeclaration.d.ts.map

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

@@ -0,0 +1,13 @@
+import { Maybe } from "purify-ts";
+import { snippets } from "../snippets.js";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+import { code } from "../ts-poet-wrapper.js";
+export function ObjectType_valueSparqlConstructTriplesFunctionDeclaration() {
+    if (!this.features.has("sparql")) {
+        return Maybe.empty();
+    }
+    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 });`);
+}
+//# sourceMappingURL=ObjectType_valueSparqlConstructTriplesFunctionDeclaration.js.map

package/dist/generators/ts/_ObjectType/ObjectType_valueSparqlWherePatternsFunctionDeclaration.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_valueSparqlWherePatternsFunctionDeclaration(this: ObjectType): Maybe<Code>;
+//# sourceMappingURL=ObjectType_valueSparqlWherePatternsFunctionDeclaration.d.ts.map

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

@@ -0,0 +1,15 @@
+import { Maybe } from "purify-ts";
+import { snippets } from "../snippets.js";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+import { code } from "../ts-poet-wrapper.js";
+export function ObjectType_valueSparqlWherePatternsFunctionDeclaration() {
+    if (!this.features.has("sparql")) {
+        return Maybe.empty();
+    }
+    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 })
+  );`);
+}
+//# sourceMappingURL=ObjectType_valueSparqlWherePatternsFunctionDeclaration.js.map

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

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

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

@@ -37,12 +37,12 @@ export declare class ShaclProperty<TypeT extends Type> extends AbstractProperty<
     };
     constructorStatements({ variables, }: Parameters<AbstractProperty<TypeT>["constructorStatements"]>[0]): readonly Code[];
     fromJsonStatements({ variables, }: Parameters<AbstractProperty<TypeT>["fromJsonStatements"]>[0]): readonly Code[];
-    fromRdfExpression({ variables, }: Parameters<AbstractProperty<TypeT>["fromRdfExpression"]>[0]): Maybe<Code>;
+    fromRdfResourceValuesExpression({ variables, }: Parameters<AbstractProperty<TypeT>["fromRdfResourceValuesExpression"]>[0]): Maybe<Code>;
     hashStatements(parameters: Parameters<AbstractProperty<TypeT>["hashStatements"]>[0]): readonly Code[];
     jsonUiSchemaElement({ variables, }: Parameters<AbstractProperty<TypeT>["jsonUiSchemaElement"]>[0]): Maybe<Code>;
     sparqlConstructTriplesExpression({ variables, }: Parameters<AbstractProperty<TypeT>["sparqlConstructTriplesExpression"]>[0]): Maybe<Code>;
     sparqlWherePatternsExpression({ variables, }: Parameters<AbstractProperty<TypeT>["sparqlWherePatternsExpression"]>[0]): ReturnType<AbstractProperty<TypeT>["sparqlWherePatternsExpression"]>;
     toJsonObjectMemberExpression(parameters: Parameters<AbstractProperty<TypeT>["toJsonObjectMemberExpression"]>[0]): Maybe<Code>;
-    toRdfStatements({ variables, }: Parameters<AbstractProperty<TypeT>["toRdfStatements"]>[0]): readonly Code[];
+    toRdfRdfResourceValuesStatements({ variables, }: Parameters<AbstractProperty<TypeT>["toRdfRdfResourceValuesStatements"]>[0]): readonly Code[];
 }
 //# sourceMappingURL=ShaclProperty.d.ts.map

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

@@ -164,7 +164,7 @@ export class ShaclProperty extends AbstractProperty {
             code `const ${this.name} = ${this.type.fromJsonExpression({ variables: { value: code `${variables.jsonObject}["${this.name}"]` } })};`,
         ];
     }
-    fromRdfExpression({ variables, }) {
+    fromRdfResourceValuesExpression({ variables, }) {
         // Assume the property has the correct range and ignore the object's RDF type.
         // This also accommodates the case where the object of a property is a dangling identifier that's not the
         // subject of any statements.
@@ -172,7 +172,7 @@ export class ShaclProperty extends AbstractProperty {
             graph: variables.graph,
             resource: variables.resource,
             propertySchema: code `${syntheticNamePrefix}schema.properties.${this.name}`,
-            typeFromRdf: code `((resourceValues) => ${this.type.fromRdfExpression({
+            typeFromRdf: code `((resourceValues) => ${this.type.fromRdfResourceValuesExpression({
                 variables: {
                     ...variables,
                     ignoreRdfType: true,
@@ -200,7 +200,7 @@ export class ShaclProperty extends AbstractProperty {
             ignoreRdfType: true,
             propertyName: this.name,
             propertySchema: code `${syntheticNamePrefix}schema.properties.${this.name}`,
-            typeSparqlConstructTriples: this.type.sparqlConstructTriplesFunction,
+            typeSparqlConstructTriples: this.type.valueSparqlConstructTriplesFunction,
             variablePrefix: variables.variablePrefix,
         }})`);
     }
@@ -215,7 +215,7 @@ export class ShaclProperty extends AbstractProperty {
                 preferredLanguages: variables.preferredLanguages,
                 propertyName: this.name,
                 propertySchema: code `${syntheticNamePrefix}schema.properties.${this.name}`,
-                typeSparqlWherePatterns: this.type.sparqlWherePatternsFunction,
+                typeSparqlWherePatterns: this.type.valueSparqlWherePatternsFunction,
                 variablePrefix: variables.variablePrefix,
             }})`,
         });
@@ -223,7 +223,7 @@ export class ShaclProperty extends AbstractProperty {
     toJsonObjectMemberExpression(parameters) {
         return Maybe.of(code `${this.name}: ${this.type.toJsonExpression(parameters)}`);
     }
-    toRdfStatements({ variables, }) {
+    toRdfRdfResourceValuesStatements({ variables, }) {
         switch (this.path.termType) {
             case "NamedNode":
                 break;
@@ -237,7 +237,7 @@ export class ShaclProperty extends AbstractProperty {
         }
         const propertyPath = propertyPathToCode(this.path);
         return [
-            code `${variables.resource}.add(${propertyPath}, ${this.type.toRdfExpression({
+            code `${variables.resource}.add(${propertyPath}, ${this.type.toRdfResourceValuesExpression({
                 variables: { ...variables, propertyPath },
             })}, ${variables.graph});`,
         ];

package/dist/generators/ts/_snippets/snippets_FocusSparqlConstructTriplesFunction.d.ts

@@ -0,0 +1,2 @@
+export declare const snippets_FocusSparqlConstructTriplesFunction: import("ts-poet/build/ConditionalOutput.js").ConditionalOutput;
+//# sourceMappingURL=snippets_FocusSparqlConstructTriplesFunction.d.ts.map

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

@@ -0,0 +1,12 @@
+import { imports } from "../imports.js";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_FocusSparqlConstructTriplesFunction = conditionalOutput(`${syntheticNamePrefix}FocusSparqlConstructTriplesFunction`, code `\
+type ${syntheticNamePrefix}FocusSparqlConstructTriplesFunction<FilterT> = 
+  (parameters: {
+    filter: FilterT | undefined;
+    focusIdentifier: ${imports.NamedNode} | ${imports.Variable};
+    ignoreRdfType: boolean;
+    variablePrefix: string;
+  }) => readonly ${imports.sparqljs}.Triple[];`);
+//# sourceMappingURL=snippets_FocusSparqlConstructTriplesFunction.js.map

package/dist/generators/ts/_snippets/snippets_FocusSparqlWherePatternsFunction.d.ts

@@ -0,0 +1,2 @@
+export declare const snippets_FocusSparqlWherePatternsFunction: import("ts-poet/build/ConditionalOutput.js").ConditionalOutput;
+//# sourceMappingURL=snippets_FocusSparqlWherePatternsFunction.d.ts.map

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

@@ -0,0 +1,14 @@
+import { imports } from "../imports.js";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+import { snippets_SparqlPattern } from "./snippets_SparqlPattern.js";
+export const snippets_FocusSparqlWherePatternsFunction = conditionalOutput(`${syntheticNamePrefix}FocusSparqlWherePatternsFunction`, code `\
+type ${syntheticNamePrefix}FocusSparqlWherePatternsFunction<FilterT> =
+  (parameters: {
+    filter: FilterT | undefined;
+    focusIdentifier: ${imports.NamedNode} | ${imports.Variable};
+    ignoreRdfType: boolean;
+    preferredLanguages: readonly string[] | undefined;
+    variablePrefix: string;
+  }) => readonly ${snippets_SparqlPattern}[];`);
+//# sourceMappingURL=snippets_FocusSparqlWherePatternsFunction.js.map

package/dist/generators/ts/_snippets/snippets_FromRdfResourceFunction.d.ts

@@ -0,0 +1,2 @@
+export declare const snippets_FromRdfResourceFunction: import("ts-poet/build/ConditionalOutput.js").ConditionalOutput;
+//# sourceMappingURL=snippets_FromRdfResourceFunction.d.ts.map