@shaclmate/compiler 4.0.28 → 4.0.30

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

@@ -6,7 +6,6 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 };
 import { Maybe } from "purify-ts";
 import { Memoize } from "typescript-memoize";
-import { imports } from "../imports.js";
 import { removeUndefined } from "../removeUndefined.js";
 import { arrayOf, code, literalOf } from "../ts-poet-wrapper.js";
 import { AbstractProperty } from "./AbstractProperty.js";
@@ -30,8 +29,8 @@ export class DiscriminantProperty extends AbstractProperty {
         return Maybe.of({
             key: this.name,
             schema: this.type.values.length > 1
-                ? code `${imports.z}.enum(${arrayOf(...this.type.values)})`
-                : code `${imports.z}.literal(${literalOf(this.type.values[0])})`,
+                ? code `${this.reusables.imports.z}.enum(${arrayOf(...this.type.values)})`
+                : code `${this.reusables.imports.z}.literal(${literalOf(this.type.values[0])})`,
         });
     }
     get jsonSignature() {
@@ -53,7 +52,7 @@ export class DiscriminantProperty extends AbstractProperty {
         return [code `const ${this.name} = ${this.initializer};`];
     }
     fromRdfResourceValuesExpression() {
-        return Maybe.of(code `${imports.Right}<${literalOf(this.namedObjectType.discriminantValue)}>(${this.initializer})`);
+        return Maybe.of(code `${this.reusables.imports.Right}<${literalOf(this.namedObjectType.discriminantValue)}>(${this.initializer})`);
     }
     hashStatements({ variables, }) {
         if (this.override) {

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

@@ -10,8 +10,6 @@ import { Maybe } from "purify-ts";
 import { invariant } from "ts-invariant";
 import { Memoize } from "typescript-memoize";
 import { codeEquals } from "../codeEquals.js";
-import { imports } from "../imports.js";
-import { rdfjsTermExpression } from "../rdfjsTermExpression.js";
 import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { arrayOf, code, joinCode } from "../ts-poet-wrapper.js";
 import { AbstractProperty } from "./AbstractProperty.js";
@@ -59,10 +57,10 @@ export class IdentifierProperty extends AbstractProperty {
         if (this.type.in_.length > 0 && this.type.kind === "IriType") {
             // Treat sh:in as a union of the IRIs
             // rdfjs.NamedNode<"http://example.com/1" | "http://example.com/2">
-            schema = code `${imports.z}.enum(${arrayOf(...this.type.in_.map((iri) => iri.value))})`;
+            schema = code `${this.reusables.imports.z}.enum(${arrayOf(...this.type.in_.map((iri) => iri.value))})`;
         }
         else {
-            schema = code `${imports.z}.string().min(1)`;
+            schema = code `${this.reusables.imports.z}.string().min(1)`;
         }
         return Maybe.of({
             key: "@id",
@@ -95,7 +93,7 @@ export class IdentifierProperty extends AbstractProperty {
             conversionBranches.push(code `if (${conversion.sourceTypeCheckExpression(parameterVariable)}) { ${this.name} = () => ${conversion.conversionExpression(parameterVariable)}; }`);
         }
         if (this.type.nodeKinds.has("BlankNode")) {
-            conversionBranches.push(code `if (${parameterVariable} === undefined) { const ${syntheticNamePrefix}eagerIdentifier = ${imports.dataFactory}.blankNode(); ${this.name} = () => ${syntheticNamePrefix}eagerIdentifier; }`);
+            conversionBranches.push(code `if (${parameterVariable} === undefined) { const ${syntheticNamePrefix}eagerIdentifier = ${this.reusables.imports.dataFactory}.blankNode(); ${this.name} = () => ${syntheticNamePrefix}eagerIdentifier; }`);
         }
         // We shouldn't need this else, since the parameter now has the never type, but have to add it to appease the TypeScript compiler
         conversionBranches.push(code `{ ${this.name} = (${parameterVariable}) satisfies never;\n }`);
@@ -111,10 +109,8 @@ export class IdentifierProperty extends AbstractProperty {
         return Maybe.of(code `${this.type.fromRdfResourceValuesExpression({
             variables: {
                 ...variables,
-                propertyPath: rdfjsTermExpression(rdf.subject, {
-                    logger: this.logger,
-                }),
-                resourceValues: code `${imports.Right}(new ${imports.Resource}.Value(${{ dataFactory: imports.dataFactory, focusResource: variables.resource, propertyPath: rdfjsTermExpression(rdf.subject, { logger: this.logger }), term: code `${variables.resource}.identifier` }}).toValues())`,
+                propertyPath: this.rdfjsTermExpression(rdf.subject),
+                resourceValues: code `${this.reusables.imports.Right}(new ${this.reusables.imports.Resource}.Value(${{ dataFactory: this.reusables.imports.dataFactory, focusResource: variables.resource, propertyPath: this.rdfjsTermExpression(rdf.subject), term: code `${variables.resource}.identifier` }}).toValues())`,
             },
         })}.chain(values => values.head())`);
     }
@@ -135,7 +131,7 @@ export class IdentifierProperty extends AbstractProperty {
                 ignoreRdfType: true, // Unused
                 preferredLanguages: variables.preferredLanguages,
                 propertyPatterns: code `[]`,
-                schema: code `${this.namedObjectType.name}.${syntheticNamePrefix}schema.properties.${this.name}.type()`,
+                schema: code `${this.namedObjectType.name}.schema.properties.${this.name}.type()`,
                 valueVariable: variables.focusIdentifier,
                 variablePrefix: variables.variablePrefix, // Unused
             }})`,

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

@@ -1,6 +1,5 @@
 import { Maybe } from "purify-ts";
 import { invariant } from "ts-invariant";
-import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code, joinCode } from "../ts-poet-wrapper.js";
 export function NamedObjectType_createFunctionDeclaration() {
     if (!this.features.has("create")) {
@@ -12,7 +11,7 @@ export function NamedObjectType_createFunctionDeclaration() {
         parametersType.push(code `{ ${joinCode(parametersPropertySignatures)} }`);
     }
     for (const parentObjectType of this.parentObjectTypes) {
-        parametersType.push(code `Parameters<typeof ${parentObjectType.name}.${syntheticNamePrefix}create>[0]`);
+        parametersType.push(code `Parameters<typeof ${parentObjectType.name}.create>[0]`);
     }
     if (parametersType.length === 0) {
         parametersType.push(code `object`);
@@ -21,7 +20,7 @@ export function NamedObjectType_createFunctionDeclaration() {
     const omitPropertyNames = [];
     const propertyStatements = [];
     for (const parentObjectType of this.parentObjectTypes) {
-        propertyInitializers.push(`...${parentObjectType.name}.${syntheticNamePrefix}create(parameters)`);
+        propertyInitializers.push(`...${parentObjectType.name}.create(parameters)`);
     }
     const parametersHasQuestionToken = this.parentObjectTypes.length === 0 &&
         parametersPropertySignatures.every((propertySignature) => propertySignature.toCodeString([]).indexOf("?:") !== -1);
@@ -44,7 +43,7 @@ export function NamedObjectType_createFunctionDeclaration() {
     invariant(propertyInitializers.length > 0);
     invariant(propertyStatements.length > 0);
     return Maybe.of(code `\
-export function ${syntheticNamePrefix}create(parameters${parametersHasQuestionToken ? "?" : ""}: ${joinCode(parametersType, { on: " & " })}): ${omitPropertyNames.length === 0 ? this.name : `Omit<${this.name}, ${omitPropertyNames.map((omitPropertyName) => `"${omitPropertyName}"`).join(" | ")}>`} {
+export function create(parameters${parametersHasQuestionToken ? "?" : ""}: ${joinCode(parametersType, { on: " & " })}): ${omitPropertyNames.length === 0 ? this.name : `Omit<${this.name}, ${omitPropertyNames.map((omitPropertyName) => `"${omitPropertyName}"`).join(" | ")}>`} {
   ${joinCode(propertyStatements)}
   return { ${propertyInitializers.join(", ")} };
 }`);

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

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

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

@@ -1,4 +1,3 @@
-import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code, joinCode } from "../ts-poet-wrapper.js";
 export function NamedObjectType_filterFunctionDeclaration() {
     const statements = [];
@@ -14,7 +13,7 @@ export function NamedObjectType_filterFunctionDeclaration() {
     }
     statements.push(code `return true;`);
     return code `\
-export function ${syntheticNamePrefix}filter(filter: ${this.filterType}, value: ${this.name}): boolean {
+export function filter(filter: ${this.filterType}, value: ${this.name}): boolean {
   ${joinCode(statements)}
 }`;
 }

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

@@ -1,4 +1,3 @@
-import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code, joinCode } from "../ts-poet-wrapper.js";
 export function NamedObjectType_filterTypeDeclaration() {
     const members = [];
@@ -14,9 +13,9 @@ export function NamedObjectType_filterTypeDeclaration() {
         }
     }
     for (const parentObjectType of this.parentObjectTypes) {
-        members.push(code `${parentObjectType.name}.${syntheticNamePrefix}Filter`);
+        members.push(code `${parentObjectType.name}.Filter`);
     }
     return code `\
-export type ${syntheticNamePrefix}Filter = ${members.length > 0 ? joinCode(members, { on: " & " }) : "object"};`;
+export type Filter = ${members.length > 0 ? joinCode(members, { on: " & " }) : "object"};`;
 }
 //# sourceMappingURL=NamedObjectType_filterTypeDeclaration.js.map

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

@@ -1,9 +1,5 @@
 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 = {
     filter: code `parameters.filter`,
@@ -14,20 +10,20 @@ export function NamedObjectType_focusSparqlConstructTriplesFunctionDeclaration()
     if (!this.features.has("sparql")) {
         return Maybe.empty();
     }
-    const rdfClassVariable = code `${imports.dataFactory}.variable!(\`\${${variables.variablePrefix}}RdfClass\`)`;
-    const rdfTypeVariable = code `${imports.dataFactory}.variable!(\`\${${variables.variablePrefix}}RdfType\`)`;
+    const rdfClassVariable = code `${this.reusables.imports.dataFactory}.variable!(\`\${${variables.variablePrefix}}RdfClass\`)`;
+    const rdfTypeVariable = code `${this.reusables.imports.dataFactory}.variable!(\`\${${variables.variablePrefix}}RdfType\`)`;
     let triplesVariableDeclarationKeyword = "const";
     const statements = [];
     for (const parentObjectType of this.parentObjectTypes) {
-        statements.push(code `triples = triples.concat(${parentObjectType.name}.${syntheticNamePrefix}focusSparqlConstructTriples(${{ filter: variables.filter, focusIdentifier: variables.focusIdentifier, ignoreRdfType: true, variablePrefix: variables.variablePrefix }}));`);
+        statements.push(code `triples = triples.concat(${parentObjectType.name}.focusSparqlConstructTriples(${{ filter: variables.filter, focusIdentifier: variables.focusIdentifier, ignoreRdfType: true, variablePrefix: variables.variablePrefix }}));`);
         triplesVariableDeclarationKeyword = "let";
     }
     if (this.fromRdfType.isJust()) {
         statements.push(code `\
 if (!parameters?.ignoreRdfType) {
   triples.push(
-    { subject: ${variables.focusIdentifier}, predicate: ${rdfjsTermExpression(rdf.type, { logger: this.logger })}, object: ${rdfTypeVariable} },
-    { subject: ${rdfTypeVariable}, predicate: ${rdfjsTermExpression(rdfs.subClassOf, { logger: this.logger })}, object: ${rdfClassVariable} }
+    { subject: ${variables.focusIdentifier}, predicate: ${this.rdfjsTermExpression(rdf.type)}, object: ${rdfTypeVariable} },
+    { subject: ${rdfTypeVariable}, predicate: ${this.rdfjsTermExpression(rdfs.subClassOf)}, object: ${rdfClassVariable} }
   );
 }`);
     }
@@ -45,10 +41,10 @@ if (!parameters?.ignoreRdfType) {
         });
     }
     return Maybe.of(code `\
-export const ${syntheticNamePrefix}focusSparqlConstructTriples: ${snippets.FocusSparqlConstructTriplesFunction}<${this.filterType}> = (${statements.length === 0 ? "_" : ""}parameters) => {
+export const focusSparqlConstructTriples: ${this.reusables.snippets.FocusSparqlConstructTriplesFunction}<${this.filterType}> = (${statements.length === 0 ? "_" : ""}parameters) => {
 ${statements.length > 0
         ? joinCode([
-            code `${triplesVariableDeclarationKeyword} triples: ${imports.sparqljs}.Triple[] = [];`,
+            code `${triplesVariableDeclarationKeyword} triples: ${this.reusables.imports.sparqljs}.Triple[] = [];`,
             ...statements,
             code `return triples;`,
         ])

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

@@ -1,9 +1,5 @@
 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 = {
     filter: code `parameters.filter`,
@@ -15,13 +11,13 @@ export function NamedObjectType_focusSparqlWherePatternsFunctionDeclaration() {
     if (!this.features.has("sparql")) {
         return Maybe.empty();
     }
-    const rdfClassVariable = code `${imports.dataFactory}.variable!(\`\${${variables.variablePrefix}}RdfClass\`)`;
-    const rdfTypeVariable = code `${imports.dataFactory}.variable!(\`\${${variables.variablePrefix}}RdfType\`)`;
+    const rdfClassVariable = code `${this.reusables.imports.dataFactory}.variable!(\`\${${variables.variablePrefix}}RdfClass\`)`;
+    const rdfTypeVariable = code `${this.reusables.imports.dataFactory}.variable!(\`\${${variables.variablePrefix}}RdfType\`)`;
     let patternsVariableDeclarationKeyword = "const";
     const statements = [];
     for (const parentObjectType of this.parentObjectTypes) {
         statements.push(code `\
-patterns = patterns.concat(${parentObjectType.name}.${syntheticNamePrefix}focusSparqlWherePatterns(${{ filter: variables.filter, focusIdentifier: variables.focusIdentifier, ignoreRdfType: true, preferredLanguages: variables.preferredLanguages, variablePrefix: variables.variablePrefix }}));`);
+patterns = patterns.concat(${parentObjectType.name}.focusSparqlWherePatterns(${{ filter: variables.filter, focusIdentifier: variables.focusIdentifier, ignoreRdfType: true, preferredLanguages: variables.preferredLanguages, variablePrefix: variables.variablePrefix }}));`);
         patternsVariableDeclarationKeyword = "let";
     }
     if (this.fromRdfType.isJust()) {
@@ -36,18 +32,18 @@ if (!parameters?.ignoreRdfType) {
     {
       type: "values" as const,
       values: [${joinCode(fromRdfTypeVariables, { on: "," })}].map((identifier) => {
-        const valuePatternRow: ${imports.sparqljs}.ValuePatternRow = {};
-        valuePatternRow[\`?\${${variables.variablePrefix}}FromRdfType\`] = identifier as ${imports.NamedNode};
+        const valuePatternRow: ${this.reusables.imports.sparqljs}.ValuePatternRow = {};
+        valuePatternRow[\`?\${${variables.variablePrefix}}FromRdfType\`] = identifier as ${this.reusables.imports.NamedNode};
         return valuePatternRow;
       }),
     },
-    ${snippets.sparqlInstancesOfPattern}({ rdfType: ${imports.dataFactory}.variable!(\`\${${variables.variablePrefix}}FromRdfType\`), subject: ${variables.focusIdentifier} }),`
-            : code `${snippets.sparqlInstancesOfPattern}({ rdfType: ${fromRdfTypeVariables[0]}, subject: ${variables.focusIdentifier} }),`}
+    ${this.reusables.snippets.sparqlInstancesOfPattern}({ rdfType: ${this.reusables.imports.dataFactory}.variable!(\`\${${variables.variablePrefix}}FromRdfType\`), subject: ${variables.focusIdentifier} }),`
+            : code `${this.reusables.snippets.sparqlInstancesOfPattern}({ rdfType: ${fromRdfTypeVariables[0]}, subject: ${variables.focusIdentifier} }),`}
     {
       triples: [
         {
           subject: ${variables.focusIdentifier},
-          predicate: ${rdfjsTermExpression(rdf.type, { logger: this.logger })},
+          predicate: ${this.rdfjsTermExpression(rdf.type)},
           object: rdfTypeVariable
         }
       ],
@@ -60,7 +56,7 @@ if (!parameters?.ignoreRdfType) {
             {
               subject: rdfTypeVariable,
               predicate: {
-                items: [${rdfjsTermExpression(rdfs.subClassOf, { logger: this.logger })}],
+                items: [${this.rdfjsTermExpression(rdfs.subClassOf)}],
                 pathType: "+" as const,
                 type: "path" as const
               },
@@ -93,10 +89,10 @@ if (!parameters?.ignoreRdfType) {
         });
     }
     return Maybe.of(code `\
-export const ${syntheticNamePrefix}focusSparqlWherePatterns: ${snippets.FocusSparqlWherePatternsFunction}<${this.filterType}> = (${statements.length === 0 ? "_" : ""}parameters) => {
+export const focusSparqlWherePatterns: ${this.reusables.snippets.FocusSparqlWherePatternsFunction}<${this.filterType}> = (${statements.length === 0 ? "_" : ""}parameters) => {
 ${statements.length > 0
         ? joinCode([
-            code `${patternsVariableDeclarationKeyword} patterns: ${snippets.SparqlPattern}[] = [];`,
+            code `${patternsVariableDeclarationKeyword} patterns: ${this.reusables.snippets.SparqlPattern}[] = [];`,
             ...statements,
             code `return patterns;`,
         ])

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

@@ -1,13 +1,12 @@
 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();
     }
     return Maybe.of(code `\
-export function ${syntheticNamePrefix}fromJson(json: ${this.jsonType().name}): ${this.name} {
-  return ${syntheticNamePrefix}create(${syntheticNamePrefix}propertiesFromJson(json));
+export function fromJson(json: ${this.jsonType().name}): ${this.name} {
+  return create(propertiesFromJson(json));
 }`);
 }
 //# sourceMappingURL=NamedObjectType_fromJsonFunctionDeclaration.js.map

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

@@ -1,5 +1,4 @@
 import { Maybe } from "purify-ts";
-import { snippets } from "../snippets.js";
 import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code, joinCode } from "../ts-poet-wrapper.js";
 export function NamedObjectType_fromRdfResourceFunctionDeclaration() {
@@ -7,11 +6,11 @@ export function NamedObjectType_fromRdfResourceFunctionDeclaration() {
         return Maybe.empty();
     }
     return Maybe.of(code `\
-export const ${syntheticNamePrefix}fromRdfResource: ${snippets.FromRdfResourceFunction}<${this.name}> = (resource, options) => {
+export const fromRdfResource: ${this.reusables.snippets.FromRdfResourceFunction}<${this.name}> = (resource, options) => {
 ${joinCode([
         code `let { context, graph, ignoreRdfType = false, objectSet, preferredLanguages } = (options ?? {});`,
         code `if (!objectSet) { objectSet = new ${syntheticNamePrefix}RdfjsDatasetObjectSet(resource.dataset); }`,
-        code `return ${code `${this.name}.${syntheticNamePrefix}propertiesFromRdfResource(resource, { context, graph, ignoreRdfType, objectSet, preferredLanguages }).map(${syntheticNamePrefix}create)`};`,
+        code `return ${code `${this.name}.propertiesFromRdfResource(resource, { context, graph, ignoreRdfType, objectSet, preferredLanguages }).map(create)`};`,
     ])}
 };`);
 }

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

@@ -1,16 +1,14 @@
 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();
     }
     return Maybe.of(code `\
-export const ${syntheticNamePrefix}fromRdfResourceValues: ${snippets.FromRdfResourceValuesFunction}<${this.name}> = (values, options) => 
+export const fromRdfResourceValues: ${this.reusables.snippets.FromRdfResourceValuesFunction}<${this.name}> = (values, options) => 
   values.chain(
     values => values.chainMap(
-      value => value.toResource().chain(resource => ${this.name}.${syntheticNamePrefix}fromRdfResource(resource, options))
+      value => value.toResource().chain(resource => ${this.name}.fromRdfResource(resource, options))
     )
   );`);
 }

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

@@ -1,13 +1,10 @@
 import { Maybe } from "purify-ts";
-import { imports } from "../imports.js";
-import { rdfjsTermExpression } from "../rdfjsTermExpression.js";
-import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code } from "../ts-poet-wrapper.js";
 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, { logger: this.logger })};`);
+export const fromRdfType: ${this.reusables.imports.NamedNode}<string> = ${this.rdfjsTermExpression(fromRdfType)};`);
 }
 //# sourceMappingURL=NamedObjectType_fromRdfTypeVariableStatement.js.map

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

@@ -1,5 +1,4 @@
 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_graphqlTypeVariableStatement() {
@@ -10,7 +9,7 @@ export function NamedObjectType_graphqlTypeVariableStatement() {
         return Maybe.empty();
     }
     return Maybe.of(code `\
-export const ${syntheticNamePrefix}GraphQL = new ${imports.GraphQLObjectType}<${this.name}, { objectSet: ${syntheticNamePrefix}ObjectSet }>(${{
+export const GraphQL = new ${this.reusables.imports.GraphQLObjectType}<${this.name}, { objectSet: ${syntheticNamePrefix}ObjectSet }>(${{
         description: this.comment.extract(),
         fields: code `() => (${this.properties.reduce((fields, property) => {
             property.graphqlField.ifJust((field) => {

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

@@ -1,5 +1,3 @@
-import { snippets } from "../snippets.js";
-import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code, joinCode } from "../ts-poet-wrapper.js";
 const hasherVariable = code `_hasher`;
 export function NamedObjectType_hashFunctionDeclarations() {
@@ -20,9 +18,9 @@ export function NamedObjectType_hashFunctionDeclarations() {
     const hashShaclPropertiesStatements = [];
     const hashStatements = [];
     for (const parentObjectType of this.parentObjectTypes) {
-        hashShaclPropertiesStatements.push(code `${parentObjectType.name}.${syntheticNamePrefix}hashShaclProperties(${this.thisVariable}, ${hasherVariable});`);
+        hashShaclPropertiesStatements.push(code `${parentObjectType.name}.hashShaclProperties(${this.thisVariable}, ${hasherVariable});`);
     }
-    hashStatements.push(code `${this.name}.${syntheticNamePrefix}hashShaclProperties(${this.thisVariable}, ${hasherVariable});`);
+    hashStatements.push(code `${this.name}.hashShaclProperties(${this.thisVariable}, ${hasherVariable});`);
     hashShaclPropertiesStatements.push(...hashOwnShaclPropertiesStatements);
     hashShaclPropertiesStatements.push(code `return ${hasherVariable};`);
     hashStatements.push(...this.properties
@@ -37,11 +35,11 @@ export function NamedObjectType_hashFunctionDeclarations() {
     hashStatements.push(code `return ${hasherVariable};`);
     return [
         code `\
-export function ${syntheticNamePrefix}hash<HasherT extends ${snippets.Hasher}>(${this.thisVariable}: ${this.name}, ${hasherVariable}: HasherT): HasherT {
+export function hash<HasherT extends ${this.reusables.snippets.Hasher}>(${this.thisVariable}: ${this.name}, ${hasherVariable}: HasherT): HasherT {
   ${joinCode(hashStatements)}
 }`,
         code `\
-export function ${syntheticNamePrefix}hashShaclProperties<HasherT extends ${snippets.Hasher}>(${this.thisVariable}: ${this.name}, ${hasherVariable}: HasherT): HasherT {
+export function hashShaclProperties<HasherT extends ${this.reusables.snippets.Hasher}>(${this.thisVariable}: ${this.name}, ${hasherVariable}: HasherT): HasherT {
   ${joinCode(hashShaclPropertiesStatements)}
 }`,
     ];

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

@@ -1,16 +1,14 @@
 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();
     }
     return Maybe.of(code `\
-export function parse(json: unknown): ${imports.Either}<Error, ${syntheticNamePrefix}Json> {
+export function parse(json: unknown): ${this.reusables.imports.Either}<Error, Json> {
   const jsonSafeParseResult = schema().safeParse(json);
-  if (!jsonSafeParseResult.success) { return ${imports.Left}(jsonSafeParseResult.error); }
-  return ${imports.Right}(jsonSafeParseResult.data);
+  if (!jsonSafeParseResult.success) { return ${this.reusables.imports.Left}(jsonSafeParseResult.error); }
+  return ${this.reusables.imports.Right}(jsonSafeParseResult.data);
 }`);
 }
 //# sourceMappingURL=NamedObjectType_jsonParseFunctionDeclaration.js.map

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

@@ -1,6 +1,4 @@
 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 NamedObjectType_jsonSchemaFunctionDeclaration() {
     if (!this.features.has("json")) {
@@ -27,7 +25,7 @@ export function NamedObjectType_jsonSchemaFunctionDeclaration() {
     // ${this.properties.every((property) => !property.mutable) ? `.readonly()` : ""}
     return Maybe.of(code `\
 export function schema() {
-  return ${imports.z}.object({${joinCode(properties, { on: "," })}}).meta(${meta}) satisfies ${imports.z}.ZodType<${syntheticNamePrefix}Json>;
+  return ${this.reusables.imports.z}.object({${joinCode(properties, { on: "," })}}).meta(${meta}) satisfies ${this.reusables.imports.z}.ZodType<Json>;
 }`);
 }
 //# sourceMappingURL=NamedObjectType_jsonSchemaFunctionDeclaration.js.map

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

@@ -1,5 +1,4 @@
 import { Maybe } from "purify-ts";
-import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code, joinCode } from "../ts-poet-wrapper.js";
 export function NamedObjectType_jsonTypeAliasDeclaration() {
     if (!this.features.has("json")) {
@@ -12,6 +11,6 @@ export function NamedObjectType_jsonTypeAliasDeclaration() {
     for (const parentObjectType of this.parentObjectTypes) {
         members.push(code `${parentObjectType.jsonType().name}`);
     }
-    return Maybe.of(code `export type ${syntheticNamePrefix}Json = ${members.length > 0 ? joinCode(members, { on: " & " }) : "object"};`);
+    return Maybe.of(code `export type Json = ${members.length > 0 ? joinCode(members, { on: " & " }) : "object"};`);
 }
 //# sourceMappingURL=NamedObjectType_jsonTypeAliasDeclaration.js.map

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

@@ -1,5 +1,4 @@
 import { Maybe } from "purify-ts";
-import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code, joinCode } from "../ts-poet-wrapper.js";
 export function NamedObjectType_jsonUiSchemaFunctionDeclaration() {
     if (!this.features.has("json")) {
@@ -7,7 +6,7 @@ export function NamedObjectType_jsonUiSchemaFunctionDeclaration() {
     }
     const variables = { scopePrefix: code `scopePrefix` };
     const elements = this.parentObjectTypes
-        .map((parentObjectType) => code `${parentObjectType.name}.${syntheticNamePrefix}Json.uiSchema({ scopePrefix })`)
+        .map((parentObjectType) => code `${parentObjectType.name}.Json.uiSchema({ scopePrefix })`)
         .concat(this.properties.flatMap((property) => property.jsonUiSchemaElement({ variables }).toList()));
     return Maybe.of(code `\
 export function uiSchema(parameters?: { scopePrefix?: string }): any {

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

@@ -13,8 +13,8 @@ export function NamedObjectType_propertiesFromJsonFunctionDeclaration() {
     const propertyReturnTypeSignatures = [];
     const returnType = [];
     this.parentObjectTypes.forEach((parentObjectType) => {
-        initializers.push(code `...${parentObjectType.name}.${syntheticNamePrefix}propertiesFromJson(${variables.jsonObject})`);
-        returnType.push(code `ReturnType<typeof ${parentObjectType.name}.${syntheticNamePrefix}propertiesFromJson>`);
+        initializers.push(code `...${parentObjectType.name}.propertiesFromJson(${variables.jsonObject})`);
+        returnType.push(code `ReturnType<typeof ${parentObjectType.name}.propertiesFromJson>`);
     });
     for (const property of this.properties) {
         const propertyFromJsonStatements = property.fromJsonStatements({
@@ -31,7 +31,7 @@ export function NamedObjectType_propertiesFromJsonFunctionDeclaration() {
         returnType.splice(0, 0, code `{ ${joinCode(propertyReturnTypeSignatures, { on: " " })} }`);
     }
     return Maybe.of(code `\
-export function ${syntheticNamePrefix}propertiesFromJson(${variables.jsonObject}: ${this.jsonType().name}): ${joinCode(returnType, { on: " & " })} {
+export function propertiesFromJson(${variables.jsonObject}: ${this.jsonType().name}): ${joinCode(returnType, { on: " & " })} {
 ${joinCode(statements)}
 }`);
 }

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

@@ -1,8 +1,5 @@
 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";
 const optionsVariable = `_${syntheticNamePrefix}options`;
@@ -24,15 +21,15 @@ export function NamedObjectType_propertiesFromRdfResourceFunctionDeclaration() {
     const returnType = [];
     this.parentObjectTypes.forEach((parentObjectType, parentObjectTypeI) => {
         chains.push({
-            expression: code `${parentObjectType.name}.${syntheticNamePrefix}propertiesFromRdfResource(${variables.resource}, { ...${optionsVariable}, ignoreRdfType: true })`,
+            expression: code `${parentObjectType.name}.propertiesFromRdfResource(${variables.resource}, { ...${optionsVariable}, ignoreRdfType: true })`,
             variable: `${syntheticNamePrefix}super${parentObjectTypeI}`,
         });
         initializers.push(code `...${syntheticNamePrefix}super${parentObjectTypeI}`);
-        returnType.push(code `${snippets.UnwrapR}<ReturnType<typeof ${parentObjectType.name}.${syntheticNamePrefix}propertiesFromRdfResource>>`);
+        returnType.push(code `${this.reusables.snippets.UnwrapR}<ReturnType<typeof ${parentObjectType.name}.propertiesFromRdfResource>>`);
     });
     this.fromRdfType.ifJust((fromRdfType) => {
         const fromRdfTypeVariable = this.fromRdfTypeVariable.unsafeCoerce();
-        const predicate = rdfjsTermExpression(rdf.type, { logger: this.logger });
+        const predicate = this.rdfjsTermExpression(rdf.type);
         // Check the expected type and its known subtypes
         const cases = new Set();
         cases.add(fromRdfType.value);
@@ -46,16 +43,16 @@ export function NamedObjectType_propertiesFromRdfResourceFunctionDeclaration() {
       // Check the expected type and its known subtypes
       switch (actualRdfType.value) {
         ${[...cases].map((fromRdfType) => `case "${fromRdfType}":`).join("\n")}
-          return ${imports.Right}(true as const);
+          return ${this.reusables.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 ${this.reusables.imports.Right}(true as const);
       }
 
-      return ${imports.Left}(new Error(\`\${${variables.resource}.identifier} has unexpected RDF type (actual: \${actualRdfType.value}, expected: ${fromRdfType.value})\`));
-    }) : ${imports.Right}(true as const)`,
+      return ${this.reusables.imports.Left}(new Error(\`\${${variables.resource}.identifier} has unexpected RDF type (actual: \${actualRdfType.value}, expected: ${fromRdfType.value})\`));
+    }) : ${this.reusables.imports.Right}(true as const)`,
             variable: "_rdfTypeCheck",
         });
     });
@@ -83,7 +80,7 @@ export function NamedObjectType_propertiesFromRdfResourceFunctionDeclaration() {
     const statements = [];
     const resultExpression = code `{ ${joinCode(initializers, { on: "," })} }`;
     if (chains.length === 0) {
-        statements.push(code `return ${imports.Right}(${resultExpression});`);
+        statements.push(code `return ${this.reusables.imports.Right}(${resultExpression});`);
     }
     else {
         statements.push(code `return ${chains
@@ -94,7 +91,7 @@ export function NamedObjectType_propertiesFromRdfResourceFunctionDeclaration() {
         returnType.splice(0, 0, code `{ ${joinCode(propertySignatures, { on: " " })} }`);
     }
     return Maybe.of(code `\
-export const ${syntheticNamePrefix}propertiesFromRdfResource: ${snippets.PropertiesFromRdfResourceFunction}<${joinCode(returnType, { on: " & " })}> = (${syntheticNamePrefix}resource, ${optionsVariable}) => {
+export const propertiesFromRdfResource: ${this.reusables.snippets.PropertiesFromRdfResourceFunction}<${joinCode(returnType, { on: " & " })}> = (${syntheticNamePrefix}resource, ${optionsVariable}) => {
 ${joinCode(statements)}
 };`);
 }

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

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

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

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