@shaclmate/compiler 4.0.8 → 4.0.10

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

@@ -11,7 +11,7 @@ const variables = {
     focusIdentifier: code `parameters.focusIdentifier`,
     variablePrefix: code `parameters.variablePrefix`,
 };
-export function ObjectType_sparqlWherePatternsFunctionDeclaration() {
+export function NamedObjectType_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=NamedObjectType_focusSparqlWherePatternsFunctionDeclaration.js.map

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

package/dist/generators/ts/_NamedObjectType/NamedObjectType_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 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};
+}`);
+}
+//# sourceMappingURL=NamedObjectType_fromJsonFunctionDeclaration.js.map

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

package/dist/generators/ts/{_ObjectType/ObjectType_fromRdfFunctionDeclaration.js → _NamedObjectType/NamedObjectType_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 NamedObjectType_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=NamedObjectType_fromRdfResourceFunctionDeclaration.js.map

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

package/dist/generators/ts/_NamedObjectType/NamedObjectType_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 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))
+    )
+  );`);
+}
+//# sourceMappingURL=NamedObjectType_fromRdfResourceValuesFunctionDeclaration.js.map

package/dist/generators/ts/_NamedObjectType/NamedObjectType_fromRdfTypeVariableStatement.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_fromRdfTypeVariableStatement(this: NamedObjectType): Maybe<Code>;
+//# sourceMappingURL=NamedObjectType_fromRdfTypeVariableStatement.d.ts.map

package/dist/generators/ts/{_ObjectType/ObjectType_fromRdfTypeVariableStatement.js → _NamedObjectType/NamedObjectType_fromRdfTypeVariableStatement.js}

@@ -3,11 +3,11 @@ import { imports } from "../imports.js";
 import { rdfjsTermExpression } from "../rdfjsTermExpression.js";
 import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code } from "../ts-poet-wrapper.js";
-export function ObjectType_fromRdfTypeVariableStatement() {
+export function NamedObjectType_fromRdfTypeVariableStatement() {
     if (!this.features.has("rdf")) {
         return Maybe.empty();
     }
     return this.fromRdfType.map((fromRdfType) => code `\
 export const ${syntheticNamePrefix}fromRdfType: ${imports.NamedNode}<string> = ${rdfjsTermExpression(fromRdfType)};`);
 }
-//# sourceMappingURL=ObjectType_fromRdfTypeVariableStatement.js.map
+//# sourceMappingURL=NamedObjectType_fromRdfTypeVariableStatement.js.map

package/dist/generators/ts/_NamedObjectType/NamedObjectType_graphqlTypeVariableStatement.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_graphqlTypeVariableStatement(this: NamedObjectType): Maybe<Code>;
+//# sourceMappingURL=NamedObjectType_graphqlTypeVariableStatement.d.ts.map

package/dist/generators/ts/{_ObjectType/ObjectType_graphqlTypeVariableStatement.js → _NamedObjectType/NamedObjectType_graphqlTypeVariableStatement.js}

@@ -2,7 +2,7 @@ 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_graphqlTypeVariableStatement() {
+export function NamedObjectType_graphqlTypeVariableStatement() {
     if (!this.features.has("graphql")) {
         return Maybe.empty();
     }
@@ -32,4 +32,4 @@ export const ${syntheticNamePrefix}GraphQL = new ${imports.GraphQLObjectType}<${
         name: this.name,
     }});`);
 }
-//# sourceMappingURL=ObjectType_graphqlTypeVariableStatement.js.map
+//# sourceMappingURL=NamedObjectType_graphqlTypeVariableStatement.js.map

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

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

package/dist/generators/ts/{_ObjectType/ObjectType_hashFunctionOrMethodDeclarations.js → _NamedObjectType/NamedObjectType_hashFunctionOrMethodDeclarations.js}

@@ -2,7 +2,7 @@ import { snippets } from "../snippets.js";
 import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code, joinCode } from "../ts-poet-wrapper.js";
 const hasherVariable = code `_hasher`;
-export function ObjectType_hashFunctionOrMethodDeclarations() {
+export function NamedObjectType_hashFunctionOrMethodDeclarations() {
     if (!this.features.has("hash")) {
         return [];
     }
@@ -70,4 +70,4 @@ ${hashShaclPropertiesPreamble}${syntheticNamePrefix}hashShaclProperties<HasherT
 }`,
     ];
 }
-//# sourceMappingURL=ObjectType_hashFunctionOrMethodDeclarations.js.map
+//# sourceMappingURL=NamedObjectType_hashFunctionOrMethodDeclarations.js.map

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

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

package/dist/generators/ts/{_ObjectType/ObjectType_interfaceDeclaration.js → _NamedObjectType/NamedObjectType_interfaceDeclaration.js}

@@ -1,6 +1,6 @@
 import { code, joinCode } from "../ts-poet-wrapper.js";
 import { tsComment } from "../tsComment.js";
-export function ObjectType_interfaceDeclaration() {
+export function NamedObjectType_interfaceDeclaration() {
     return code `\
 ${this.comment
         .alt(this.label)
@@ -13,4 +13,4 @@ ${this.comment
   ${joinCode(this.properties.flatMap((property) => property.declaration.toList()))}
 }`;
 }
-//# sourceMappingURL=ObjectType_interfaceDeclaration.js.map
+//# sourceMappingURL=NamedObjectType_interfaceDeclaration.js.map

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

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

package/dist/generators/ts/{_ObjectType/ObjectType_isTypeFunctionDeclaration.js → _NamedObjectType/NamedObjectType_isTypeFunctionDeclaration.js}

@@ -1,14 +1,14 @@
 import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code } from "../ts-poet-wrapper.js";
-export function ObjectType_isTypeFunctionDeclaration() {
+export function NamedObjectType_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;
   }
 }`;
 }
-//# sourceMappingURL=ObjectType_isTypeFunctionDeclaration.js.map
+//# sourceMappingURL=NamedObjectType_isTypeFunctionDeclaration.js.map

package/dist/generators/ts/_NamedObjectType/NamedObjectType_jsonParseFunctionDeclaration.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_jsonParseFunctionDeclaration(this: NamedObjectType): Maybe<Code>;
+//# sourceMappingURL=NamedObjectType_jsonParseFunctionDeclaration.d.ts.map

package/dist/generators/ts/_NamedObjectType/NamedObjectType_jsonParseFunctionDeclaration.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 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);
+  if (!jsonSafeParseResult.success) { return ${imports.Left}(jsonSafeParseResult.error); }
+  return ${imports.Right}(jsonSafeParseResult.data);
+}`);
+}
+//# sourceMappingURL=NamedObjectType_jsonParseFunctionDeclaration.js.map

package/dist/generators/ts/_NamedObjectType/NamedObjectType_jsonSchemaFunctionDeclaration.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_jsonSchemaFunctionDeclaration(this: NamedObjectType): Maybe<Code>;
+//# sourceMappingURL=NamedObjectType_jsonSchemaFunctionDeclaration.d.ts.map

package/dist/generators/ts/{_ObjectType/ObjectType_jsonZodSchemaFunctionDeclaration.js → _NamedObjectType/NamedObjectType_jsonSchemaFunctionDeclaration.js}

@@ -2,21 +2,21 @@ import { Maybe } from "purify-ts";
 import { imports } from "../imports.js";
 import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code, joinCode } from "../ts-poet-wrapper.js";
-export function ObjectType_jsonZodSchemaFunctionDeclaration() {
+export function NamedObjectType_jsonSchemaFunctionDeclaration() {
     if (!this.features.has("json")) {
         return Maybe.empty();
     }
     const mergeZodObjectSchemas = [];
     for (const parentObjectType of this.parentObjectTypes) {
-        mergeZodObjectSchemas.push(parentObjectType.jsonZodSchema({ context: "type" }));
+        mergeZodObjectSchemas.push(parentObjectType.jsonSchema({ context: "type" }));
     }
     if (this.properties.length > 0) {
         mergeZodObjectSchemas.push(code `${imports.z}.object({ ${joinCode(this.properties
-            .flatMap((property) => property.jsonZodSchema.toList())
+            .flatMap((property) => property.jsonZchema.toList())
             .map(({ key, schema }) => code `"${key}": ${schema}`), { on: "," })} })`);
     }
     return Maybe.of(code `\
-export function ${syntheticNamePrefix}jsonZodSchema() {
+export function schema() {
   return ${mergeZodObjectSchemas.length > 0
         ? mergeZodObjectSchemas.reduce((merged, zodObjectSchema) => {
             if (merged === null) {
@@ -27,4 +27,4 @@ export function ${syntheticNamePrefix}jsonZodSchema() {
         : `${imports.z}.object()`} satisfies ${imports.z}.ZodType<${syntheticNamePrefix}Json>;
 }`);
 }
-//# sourceMappingURL=ObjectType_jsonZodSchemaFunctionDeclaration.js.map
+//# sourceMappingURL=NamedObjectType_jsonSchemaFunctionDeclaration.js.map

package/dist/generators/ts/_NamedObjectType/NamedObjectType_jsonTypeAliasDeclaration.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_jsonTypeAliasDeclaration(this: NamedObjectType): Maybe<Code>;
+//# sourceMappingURL=NamedObjectType_jsonTypeAliasDeclaration.d.ts.map

package/dist/generators/ts/{_ObjectType/ObjectType_jsonTypeAliasDeclaration.js → _NamedObjectType/NamedObjectType_jsonTypeAliasDeclaration.js}

@@ -1,7 +1,7 @@
 import { Maybe } from "purify-ts";
 import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code, joinCode } from "../ts-poet-wrapper.js";
-export function ObjectType_jsonTypeAliasDeclaration() {
+export function NamedObjectType_jsonTypeAliasDeclaration() {
     if (!this.features.has("json")) {
         return Maybe.empty();
     }
@@ -14,4 +14,4 @@ export function ObjectType_jsonTypeAliasDeclaration() {
     }
     return Maybe.of(code `export type ${syntheticNamePrefix}Json = ${members.length > 0 ? joinCode(members, { on: " & " }) : "object"};`);
 }
-//# sourceMappingURL=ObjectType_jsonTypeAliasDeclaration.js.map
+//# sourceMappingURL=NamedObjectType_jsonTypeAliasDeclaration.js.map

package/dist/generators/ts/_NamedObjectType/NamedObjectType_jsonUiSchemaFunctionDeclaration.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_jsonUiSchemaFunctionDeclaration(this: NamedObjectType): Maybe<Code>;
+//# sourceMappingURL=NamedObjectType_jsonUiSchemaFunctionDeclaration.d.ts.map

package/dist/generators/ts/{_ObjectType/ObjectType_jsonUiSchemaFunctionDeclaration.js → _NamedObjectType/NamedObjectType_jsonUiSchemaFunctionDeclaration.js}

@@ -1,18 +1,18 @@
 import { Maybe } from "purify-ts";
 import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code, joinCode } from "../ts-poet-wrapper.js";
-export function ObjectType_jsonUiSchemaFunctionDeclaration() {
+export function NamedObjectType_jsonUiSchemaFunctionDeclaration() {
     if (!this.features.has("json")) {
         return Maybe.empty();
     }
     const variables = { scopePrefix: code `scopePrefix` };
     const elements = this.parentObjectTypes
-        .map((parentObjectType) => code `${parentObjectType.staticModuleName}.${syntheticNamePrefix}jsonUiSchema({ scopePrefix })`)
+        .map((parentObjectType) => code `${parentObjectType.staticModuleName}.${syntheticNamePrefix}Json.uiSchema({ scopePrefix })`)
         .concat(this.ownProperties.flatMap((property) => property.jsonUiSchemaElement({ variables }).toList()));
     return Maybe.of(code `\
-export function ${syntheticNamePrefix}jsonUiSchema(parameters?: { scopePrefix?: string }): any {
+export function uiSchema(parameters?: { scopePrefix?: string }): any {
   const scopePrefix = parameters?.scopePrefix ?? "#";
   return { "elements": [ ${joinCode(elements, { on: "," })} ], label: "${this.label.orDefault(this.name)}", type: "Group" };
 }`);
 }
-//# sourceMappingURL=ObjectType_jsonUiSchemaFunctionDeclaration.js.map
+//# sourceMappingURL=NamedObjectType_jsonUiSchemaFunctionDeclaration.js.map

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

@@ -0,0 +1,9 @@
+export declare function NamedObjectType_objectSetMethodNames(this: {
+    readonly name: string;
+}): {
+    object: string;
+    objectCount: string;
+    objectIdentifiers: string;
+    objects: string;
+};
+//# sourceMappingURL=NamedObjectType_objectSetMethodNames.d.ts.map

package/dist/generators/ts/{_ObjectType/ObjectType_objectSetMethodNames.js → _NamedObjectType/NamedObjectType_objectSetMethodNames.js}

@@ -1,6 +1,6 @@
 import { camelCase, trainCase } from "change-case";
 import plur from "plur";
-export function ObjectType_objectSetMethodNames() {
+export function NamedObjectType_objectSetMethodNames() {
     const prefixSingular = camelCase(this.name);
     const thisNameParts = trainCase(this.name).split("-");
     let prefixPlural = camelCase(`${thisNameParts.slice(0, thisNameParts.length - 1).join("")}${plur(thisNameParts[thisNameParts.length - 1])}`);
@@ -15,4 +15,4 @@ export function ObjectType_objectSetMethodNames() {
         objects: prefixPlural,
     };
 }
-//# sourceMappingURL=ObjectType_objectSetMethodNames.js.map
+//# sourceMappingURL=NamedObjectType_objectSetMethodNames.js.map

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

package/dist/generators/ts/_NamedObjectType/NamedObjectType_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 NamedObjectType_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=NamedObjectType_propertiesFromJsonFunctionDeclaration.js.map

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

package/dist/generators/ts/{_ObjectType/ObjectType_propertiesFromRdfFunctionDeclaration.js → _NamedObjectType/NamedObjectType_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 NamedObjectType_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=NamedObjectType_propertiesFromRdfResourceFunctionDeclaration.js.map

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

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

package/dist/generators/ts/{_ObjectType/ObjectType_schemaVariableStatement.js → _NamedObjectType/NamedObjectType_schemaVariableStatement.js}

@@ -1,10 +1,9 @@
 import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code, joinCode } from "../ts-poet-wrapper.js";
-export function ObjectType_schemaVariableStatement() {
+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;
-`;
+        .concat(this.ownProperties.map((property) => code `${property.name}: ${property.schema}`)), { on: ", " })} } } as const;`;
 }
-//# sourceMappingURL=ObjectType_schemaVariableStatement.js.map
+//# sourceMappingURL=NamedObjectType_schemaVariableStatement.js.map

package/dist/generators/ts/{_ObjectType/ObjectType_sparqlConstructQueryFunctionDeclaration.d.ts → _NamedObjectType/NamedObjectType_sparqlConstructQueryFunctionDeclaration.d.ts}

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

package/dist/generators/ts/{_ObjectType/ObjectType_sparqlConstructQueryFunctionDeclaration.js → _NamedObjectType/NamedObjectType_sparqlConstructQueryFunctionDeclaration.js}

@@ -4,7 +4,7 @@ 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() {
+export function NamedObjectType_sparqlConstructQueryFunctionDeclaration() {
     if (!this.features.has("sparql")) {
         return Maybe.empty();
     }
@@ -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,
@@ -39,4 +39,4 @@ export function ${syntheticNamePrefix}sparqlConstructQuery({ filter, ignoreRdfTy
   };
 }`);
 }
-//# sourceMappingURL=ObjectType_sparqlConstructQueryFunctionDeclaration.js.map
+//# sourceMappingURL=NamedObjectType_sparqlConstructQueryFunctionDeclaration.js.map

package/dist/generators/ts/{_ObjectType/ObjectType_sparqlConstructQueryStringFunctionDeclaration.d.ts → _NamedObjectType/NamedObjectType_sparqlConstructQueryStringFunctionDeclaration.d.ts}

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

package/dist/generators/ts/{_ObjectType/ObjectType_sparqlConstructQueryStringFunctionDeclaration.js → _NamedObjectType/NamedObjectType_sparqlConstructQueryStringFunctionDeclaration.js}

@@ -2,7 +2,7 @@ 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_sparqlConstructQueryStringFunctionDeclaration() {
+export function NamedObjectType_sparqlConstructQueryStringFunctionDeclaration() {
     if (!this.features.has("sparql")) {
         return Maybe.empty();
     }
@@ -11,4 +11,4 @@ export function ${syntheticNamePrefix}sparqlConstructQueryString(parameters: Par
   return new ${imports.sparqljs}.Generator(parameters).stringify(${this.staticModuleName}.${syntheticNamePrefix}sparqlConstructQuery(parameters));
 }`);
 }
-//# sourceMappingURL=ObjectType_sparqlConstructQueryStringFunctionDeclaration.js.map
+//# sourceMappingURL=NamedObjectType_sparqlConstructQueryStringFunctionDeclaration.js.map

package/dist/generators/ts/_NamedObjectType/NamedObjectType_toJsonFunctionOrMethodDeclaration.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_toJsonFunctionOrMethodDeclaration(this: NamedObjectType): Maybe<Code>;
+//# sourceMappingURL=NamedObjectType_toJsonFunctionOrMethodDeclaration.d.ts.map