@shaclmate/compiler 4.0.29 → 4.0.30

package/dist/generators/ts/ListType.js

@@ -7,9 +7,6 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 import { rdf } from "@tpluscode/rdf-ns-builders";
 import { Memoize } from "typescript-memoize";
 import { AbstractCollectionType } from "./AbstractCollectionType.js";
-import { imports } from "./imports.js";
-import { rdfjsTermExpression } from "./rdfjsTermExpression.js";
-import { snippets } from "./snippets.js";
 import { code, joinCode } from "./ts-poet-wrapper.js";
 export class ListType extends AbstractCollectionType {
     identifierNodeKind;
@@ -21,10 +18,10 @@ export class ListType extends AbstractCollectionType {
         this.toRdfTypes = toRdfTypes;
     }
     get valueSparqlConstructTriplesFunction() {
-        return code `${snippets.listSparqlConstructTriples}<${this.itemType.filterType}, ${this.itemType.schemaType}>(${this.itemType.valueSparqlConstructTriplesFunction})`;
+        return code `${this.reusables.snippets.listSparqlConstructTriples}<${this.itemType.filterType}, ${this.itemType.schemaType}>(${this.itemType.valueSparqlConstructTriplesFunction})`;
     }
     get valueSparqlWherePatternsFunction() {
-        return code `${snippets.listSparqlWherePatterns}<${this.itemType.filterType}, ${this.itemType.schemaType}>(${this.itemType.valueSparqlWherePatternsFunction})`;
+        return code `${this.reusables.snippets.listSparqlWherePatterns}<${this.itemType.filterType}, ${this.itemType.schemaType}>(${this.itemType.valueSparqlWherePatternsFunction})`;
     }
     fromRdfResourceValuesExpression({ variables, }) {
         return joinCode([
@@ -35,7 +32,7 @@ export class ListType extends AbstractCollectionType {
           valueList => ${this.itemType.fromRdfResourceValuesExpression({
                 variables: {
                     ...variables,
-                    resourceValues: code `${imports.Right}(${imports.Resource}.Values.fromArray({ focusResource: ${variables.resource}, propertyPath: ${variables.propertyPath}, values: valueList.toArray() }))`,
+                    resourceValues: code `${this.reusables.imports.Right}(${this.reusables.imports.Resource}.Values.fromArray({ focusResource: ${variables.resource}, propertyPath: ${variables.propertyPath}, values: valueList.toArray() }))`,
                 },
             })}
       ))`, // Resource.Values<Resource.Values> to Resource.Values<item type arrays>
@@ -52,12 +49,12 @@ export class ListType extends AbstractCollectionType {
         switch (this.identifierNodeKind) {
             case "BlankNode": {
                 mintListIdentifierFunction =
-                    mintSubListIdentifierFunction = code `(() => ${imports.dataFactory}.blankNode())`;
-                resourceTypeName = code `${imports.Resource}<${imports.BlankNode}>`;
+                    mintSubListIdentifierFunction = code `(() => ${this.reusables.imports.dataFactory}.blankNode())`;
+                resourceTypeName = code `${this.reusables.imports.Resource}<${this.reusables.imports.BlankNode}>`;
                 break;
             }
             case "IRI": {
-                resourceTypeName = code `${imports.Resource}<${imports.NamedNode}>`;
+                resourceTypeName = code `${this.reusables.imports.Resource}<${this.reusables.imports.NamedNode}>`;
                 throw new RangeError("list IRI minting is unsupported");
             }
         }
@@ -66,16 +63,16 @@ export class ListType extends AbstractCollectionType {
       currentSubListResource = listResource;
     } else {
       const newSubListResource = ${variables.resourceSet}.resource(${mintSubListIdentifierFunction}());
-      currentSubListResource!.add(${rdfjsTermExpression(rdf.rest, { logger: this.logger })}, newSubListResource.identifier, ${variables.graph});
+      currentSubListResource!.add(${this.rdfjsTermExpression(rdf.rest)}, newSubListResource.identifier, ${variables.graph});
       currentSubListResource = newSubListResource;
     }
     
-    ${joinCode(this.toRdfTypes.map((rdfType) => code `currentSubListResource.add(${rdfjsTermExpression(rdf.type, { logger: this.logger })}, ${imports.dataFactory}.namedNode("${rdfType.value}"), ${variables.graph})`))}
+    ${joinCode(this.toRdfTypes.map((rdfType) => code `currentSubListResource.add(${this.rdfjsTermExpression(rdf.type)}, ${this.reusables.imports.dataFactory}.namedNode("${rdfType.value}"), ${variables.graph})`))}
     
-    currentSubListResource.add(${rdfjsTermExpression(rdf.first, { logger: this.logger })}, ${this.itemType.toRdfResourceValuesExpression({ variables: { graph: variables.graph, propertyPath: rdfjsTermExpression(rdf.first, { logger: this.logger }), resource: code `currentSubListResource`, resourceSet: variables.resourceSet, value: code `item` } })}, ${variables.graph});
+    currentSubListResource.add(${this.rdfjsTermExpression(rdf.first)}, ${this.itemType.toRdfResourceValuesExpression({ variables: { graph: variables.graph, propertyPath: this.rdfjsTermExpression(rdf.first), resource: code `currentSubListResource`, resourceSet: variables.resourceSet, value: code `item` } })}, ${variables.graph});
 
     if (itemIndex + 1 === list.length) {
-      currentSubListResource.add(${rdfjsTermExpression(rdf.rest, { logger: this.logger })}, ${rdfjsTermExpression(rdf.nil, { logger: this.logger })}, ${variables.graph});
+      currentSubListResource.add(${this.rdfjsTermExpression(rdf.rest)}, ${this.rdfjsTermExpression(rdf.nil)}, ${variables.graph});
     }
     
     return { currentSubListResource, listResource };
@@ -87,7 +84,7 @@ export class ListType extends AbstractCollectionType {
     currentSubListResource: ${resourceTypeName} | null;
     listResource: ${resourceTypeName};
   },
-).listResource.identifier : ${rdfjsTermExpression(rdf.nil, { logger: this.logger })}]`;
+).listResource.identifier : ${this.rdfjsTermExpression(rdf.nil)}]`;
     }
     toStringExpression({ variables, }) {
         return code `\`[\${${variables.value}.map(item => (${this.itemType.toStringExpression({ variables: { value: code `item` } })}))}]\``;

package/dist/generators/ts/LiteralType.js

@@ -1,20 +1,18 @@
 import { xsd } from "@tpluscode/rdf-ns-builders";
 import { AbstractLiteralType } from "./AbstractLiteralType.js";
-import { imports } from "./imports.js";
-import { snippets } from "./snippets.js";
 import { code } from "./ts-poet-wrapper.js";
 export class LiteralType extends AbstractLiteralType {
-    filterFunction = code `${snippets.filterLiteral}`;
-    filterType = code `${snippets.LiteralFilter}`;
+    filterFunction = code `${this.reusables.snippets.filterLiteral}`;
+    filterType = code `${this.reusables.snippets.LiteralFilter}`;
     kind = "LiteralType";
-    name = code `${imports.Literal}`;
-    schemaType = code `${snippets.LiteralSchema}`;
-    valueSparqlWherePatternsFunction = code `${snippets.literalSparqlWherePatterns}`;
+    name = code `${this.reusables.imports.Literal}`;
+    schemaType = code `${this.reusables.snippets.LiteralSchema}`;
+    valueSparqlWherePatternsFunction = code `${this.reusables.snippets.literalSparqlWherePatterns}`;
     get graphqlType() {
         throw new Error("not implemented");
     }
     fromJsonExpression({ variables, }) {
-        return code `${imports.dataFactory}.literal(${variables.value}["@value"], ${variables.value}["@language"] !== undefined ? ${variables.value}["@language"] : (${variables.value}["@type"] !== undefined ? ${imports.dataFactory}.namedNode(${variables.value}["@type"]!) : undefined))`;
+        return code `${this.reusables.imports.dataFactory}.literal(${variables.value}["@value"], ${variables.value}["@language"] !== undefined ? ${variables.value}["@language"] : (${variables.value}["@type"] !== undefined ? ${this.reusables.imports.dataFactory}.namedNode(${variables.value}["@type"]!) : undefined))`;
     }
     graphqlResolveExpression(_parameters) {
         throw new Error("not implemented");
@@ -34,9 +32,9 @@ export class LiteralType extends AbstractLiteralType {
     }
     jsonSchema({ includeDiscriminantProperty, }) {
         const discriminantProperty = includeDiscriminantProperty
-            ? code `, termType: ${imports.z}.literal("Literal")`
+            ? code `, termType: ${this.reusables.imports.z}.literal("Literal")`
             : "";
-        return code `${imports.z}.object({ "@language": ${imports.z}.string().optional()${discriminantProperty}, "@type": ${imports.z}.string().optional(), "@value": ${imports.z}.string() })`;
+        return code `${this.reusables.imports.z}.object({ "@language": ${this.reusables.imports.z}.string().optional()${discriminantProperty}, "@type": ${this.reusables.imports.z}.string().optional(), "@value": ${this.reusables.imports.z}.string() })`;
     }
     toJsonExpression({ includeDiscriminantProperty, variables, }) {
         return code `{ "@language": ${variables.value}.language.length > 0 ? ${variables.value}.language : undefined${includeDiscriminantProperty ? `, "termType": "Literal" as const` : ""}, "@type": ${variables.value}.datatype.value !== "${xsd.string.value}" ? ${variables.value}.datatype.value : undefined, "@value": ${variables.value}.value }`;

package/dist/generators/ts/NamedObjectType.d.ts

@@ -12,7 +12,6 @@ import type { TsFeature } from "./TsFeature.js";
 import type { Type } from "./Type.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare class NamedObjectType extends AbstractType {
-    private readonly imports;
     protected readonly toRdfTypes: readonly NamedNode[];
     readonly extern: boolean;
     readonly features: ReadonlySet<TsFeature>;
@@ -24,13 +23,12 @@ export declare class NamedObjectType extends AbstractType {
     readonly recursive: boolean;
     readonly synthetic: boolean;
     readonly typeofs: NonEmptyList<"object">;
-    constructor({ extern, features, fromRdfType, identifierType, imports, lazyAncestorObjectTypes, lazyChildObjectTypes, lazyDescendantObjectTypes, lazyDiscriminantProperty, lazyParentObjectTypes, lazyProperties, name, recursive, synthetic, toRdfTypes, ...superParameters }: {
+    constructor({ extern, features, fromRdfType, identifierType, lazyAncestorObjectTypes, lazyChildObjectTypes, lazyDescendantObjectTypes, lazyDiscriminantProperty, lazyParentObjectTypes, lazyProperties, name, recursive, synthetic, toRdfTypes, ...superParameters }: {
         comment: Maybe<string>;
         extern: boolean;
         features: ReadonlySet<TsFeature>;
         fromRdfType: Maybe<NamedNode>;
         identifierType: BlankNodeType | IdentifierType | IriType;
-        imports: readonly string[];
         label: Maybe<string>;
         lazyAncestorObjectTypes: () => readonly NamedObjectType[];
         lazyChildObjectTypes: () => readonly NamedObjectType[];

package/dist/generators/ts/NamedObjectType.js

@@ -42,11 +42,9 @@ import { NamedObjectType_valueSparqlConstructTriplesFunctionDeclaration } from "
 import { NamedObjectType_valueSparqlWherePatternsFunctionDeclaration } from "./_NamedObjectType/NamedObjectType_valueSparqlWherePatternsFunctionDeclaration.js";
 import { ShaclProperty as _ShaclProperty } from "./_NamedObjectType/ShaclProperty.js";
 import { AbstractType } from "./AbstractType.js";
-import { imports } from "./imports.js";
 import { syntheticNamePrefix } from "./syntheticNamePrefix.js";
 import { code, def, joinCode } from "./ts-poet-wrapper.js";
 export class NamedObjectType extends AbstractType {
-    imports;
     toRdfTypes;
     extern;
     features;
@@ -58,13 +56,12 @@ export class NamedObjectType extends AbstractType {
     recursive;
     synthetic;
     typeofs = NonEmptyList(["object"]);
-    constructor({ extern, features, fromRdfType, identifierType, imports, lazyAncestorObjectTypes, lazyChildObjectTypes, lazyDescendantObjectTypes, lazyDiscriminantProperty, lazyParentObjectTypes, lazyProperties, name, recursive, synthetic, toRdfTypes, ...superParameters }) {
+    constructor({ extern, features, fromRdfType, identifierType, lazyAncestorObjectTypes, lazyChildObjectTypes, lazyDescendantObjectTypes, lazyDiscriminantProperty, lazyParentObjectTypes, lazyProperties, name, recursive, synthetic, toRdfTypes, ...superParameters }) {
         super(superParameters);
         this.extern = extern;
         this.features = features;
         this.fromRdfType = fromRdfType;
         this.identifierType = identifierType;
-        this.imports = imports;
         // Lazily initialize some members in getters to avoid recursive construction
         this.lazyAncestorObjectTypes = lazyAncestorObjectTypes;
         this.lazyChildObjectTypes = lazyChildObjectTypes;
@@ -98,9 +95,6 @@ export class NamedObjectType extends AbstractType {
     }
     get declaration() {
         const declarations = [];
-        for (const import_ of this.imports) {
-            declarations.push(code `${import_}`);
-        }
         if (!this.extern) {
             const staticModuleDeclarations = [];
             declarations.push(NamedObjectType_interfaceDeclaration.call(this));
@@ -112,9 +106,19 @@ export class NamedObjectType extends AbstractType {
             ];
             staticModuleDeclarations.push(...NamedObjectType_graphqlTypeVariableStatement.call(this).toList(), ...identifierTypeDeclarations.call(this), ...NamedObjectType_jsonTypeAliasDeclaration.call(this).toList(), ...(jsonModuleDeclarations.length > 0
                 ? [
-                    code `export namespace ${syntheticNamePrefix}Json { ${joinCode(jsonModuleDeclarations, { on: "\n\n" })} }`,
+                    code `export namespace Json { ${joinCode(jsonModuleDeclarations, { on: "\n\n" })} }`,
                 ]
-                : []), NamedObjectType_filterFunctionDeclaration.call(this), NamedObjectType_filterTypeDeclaration.call(this), ...NamedObjectType_focusSparqlConstructTriplesFunctionDeclaration.bind(this)().toList(), ...NamedObjectType_focusSparqlWherePatternsFunctionDeclaration.bind(this)().toList(), ...NamedObjectType_fromJsonFunctionDeclaration.call(this).toList(), ...NamedObjectType_fromRdfResourceFunctionDeclaration.call(this).toList(), ...NamedObjectType_fromRdfResourceValuesFunctionDeclaration.call(this).toList(), ...NamedObjectType_fromRdfTypeVariableStatement.call(this).toList(), NamedObjectType_isTypeFunctionDeclaration.call(this), ...NamedObjectType_propertiesFromJsonFunctionDeclaration.bind(this)().toList(), ...NamedObjectType_propertiesFromRdfResourceFunctionDeclaration.bind(this)().toList(), NamedObjectType_schemaVariableStatement.call(this), ...NamedObjectType_sparqlConstructQueryFunctionDeclaration.bind(this)().toList(), ...NamedObjectType_sparqlConstructQueryStringFunctionDeclaration.bind(this)().toList(), ...NamedObjectType_toJsonFunctionDeclaration.call(this).toList(), ...NamedObjectType_toRdfResourceFunctionDeclaration.call(this).toList(), ...NamedObjectType_toStringFunctionDeclarations.call(this), ...NamedObjectType_valueSparqlConstructTriplesFunctionDeclaration.bind(this)().toList(), ...NamedObjectType_valueSparqlWherePatternsFunctionDeclaration.bind(this)().toList());
+                : []), NamedObjectType_filterFunctionDeclaration.call(this), NamedObjectType_filterTypeDeclaration.call(this), ...NamedObjectType_focusSparqlConstructTriplesFunctionDeclaration.bind(this)().toList(), ...NamedObjectType_focusSparqlWherePatternsFunctionDeclaration.bind(this)().toList(), ...NamedObjectType_fromJsonFunctionDeclaration.call(this).toList(), ...NamedObjectType_fromRdfResourceFunctionDeclaration.call(this).toList(), ...NamedObjectType_fromRdfResourceValuesFunctionDeclaration.call(this).toList(), ...NamedObjectType_fromRdfTypeVariableStatement.call(this).toList(), NamedObjectType_isTypeFunctionDeclaration.call(this), ...NamedObjectType_propertiesFromJsonFunctionDeclaration.bind(this)().toList(), ...NamedObjectType_propertiesFromRdfResourceFunctionDeclaration.bind(this)().toList(), NamedObjectType_schemaVariableStatement.call(this), ...NamedObjectType_sparqlConstructQueryFunctionDeclaration.bind({
+                features: this.features,
+                filterType: this.filterType,
+                name: this.name,
+                reusables: this.reusables,
+            })().toList(), ...NamedObjectType_sparqlConstructQueryStringFunctionDeclaration.bind({
+                features: this.features,
+                filterType: this.filterType,
+                name: this.name,
+                reusables: this.reusables,
+            })().toList(), ...NamedObjectType_toJsonFunctionDeclaration.call(this).toList(), ...NamedObjectType_toRdfResourceFunctionDeclaration.call(this).toList(), ...NamedObjectType_toStringFunctionDeclarations.call(this), ...NamedObjectType_valueSparqlConstructTriplesFunctionDeclaration.bind(this)().toList(), ...NamedObjectType_valueSparqlWherePatternsFunctionDeclaration.bind(this)().toList());
             if (staticModuleDeclarations.length > 0) {
                 declarations.push(code `\
 export namespace ${def(this.name)} {
@@ -144,22 +148,22 @@ ${joinCode(staticModuleDeclarations, { on: "\n\n" })}
         return this.name;
     }
     get equalsFunction() {
-        return code `${this.name}.${syntheticNamePrefix}equals`;
+        return code `${this.name}.equals`;
     }
     get filterFunction() {
-        return code `${this.name}.${syntheticNamePrefix}filter`;
+        return code `${this.name}.filter`;
     }
     get filterType() {
-        return code `${this.name}.${syntheticNamePrefix}Filter`;
+        return code `${this.name}.Filter`;
     }
     get fromRdfTypeVariable() {
-        return this.fromRdfType.map(() => code `${this.name}.${syntheticNamePrefix}fromRdfType`);
+        return this.fromRdfType.map(() => code `${this.name}.fromRdfType`);
     }
     get graphqlType() {
-        return new AbstractType.GraphqlType(code `${this.name}.${syntheticNamePrefix}GraphQL`);
+        return new AbstractType.GraphqlType(code `${this.name}.GraphQL`, this.reusables);
     }
     get identifierTypeAlias() {
-        return code `${this.name}.${syntheticNamePrefix}Identifier`;
+        return code `${this.name}.Identifier`;
     }
     get mutable() {
         return this.properties.some((property) => property.mutable);
@@ -181,7 +185,7 @@ ${joinCode(staticModuleDeclarations, { on: "\n\n" })}
         return properties;
     }
     get schema() {
-        return code `${this.name}.${syntheticNamePrefix}schema`;
+        return code `${this.name}.schema`;
     }
     get schemaType() {
         return code `typeof ${this.schema}`;
@@ -193,55 +197,53 @@ ${joinCode(staticModuleDeclarations, { on: "\n\n" })}
         if (this.parentObjectTypes.length > 0) {
             return this.parentObjectTypes[0].toRdfjsResourceType;
         }
-        return code `${imports.Resource}${this.identifierType.kind === "IriType" ? code `<${imports.NamedNode}>` : ""}`;
+        return code `${this.reusables.imports.Resource}${this.identifierType.kind === "IriType" ? code `<${this.reusables.imports.NamedNode}>` : ""}`;
     }
     get valueSparqlConstructTriplesFunction() {
-        return code `${this.name}.${syntheticNamePrefix}valueSparqlConstructTriples`;
+        return code `${this.name}.valueSparqlConstructTriples`;
     }
     get valueSparqlWherePatternsFunction() {
-        return code `${this.name}.${syntheticNamePrefix}valueSparqlWherePatterns`;
+        return code `${this.name}.valueSparqlWherePatterns`;
     }
     get thisVariable() {
         return code `_${camelCase(this.name)}`;
     }
     fromJsonExpression({ variables, }) {
         // Assumes the JSON object has been recursively validated already.
-        return code `${this.name}.${syntheticNamePrefix}fromJson(${variables.value})`;
+        return code `${this.name}.fromJson(${variables.value})`;
     }
     fromRdfResourceValuesExpression({ variables, }) {
         const { resourceValues, ...options } = variables;
-        return code `${this.name}.${syntheticNamePrefix}fromRdfResourceValues(${resourceValues}, ${options})`;
+        return code `${this.name}.fromRdfResourceValues(${resourceValues}, ${options})`;
     }
     graphqlResolveExpression({ variables, }) {
         return variables.value;
     }
     hashStatements({ variables, }) {
-        return [
-            code `${this.name}.${syntheticNamePrefix}hash(${variables.value}, ${variables.hasher});`,
-        ];
+        return [code `${this.name}.hash(${variables.value}, ${variables.hasher});`];
     }
     jsonSchema({ context, }) {
-        let expression = code `${this.name}.${syntheticNamePrefix}Json.schema()`;
+        let expression = code `${this.name}.Json.schema()`;
         if (context === "property" &&
             this.properties.some((property) => property.recursive)) {
-            expression = code `${imports.z}.lazy((): ${imports.z}.ZodType<${this.name}.${syntheticNamePrefix}Json> => ${expression})`;
+            expression = code `${this.reusables.imports.z}.lazy((): ${this.reusables.imports.z}.ZodType<${this.name}.Json> => ${expression})`;
         }
         return expression;
     }
     jsonType() {
-        return new AbstractType.JsonType(code `${this.name}.${syntheticNamePrefix}Json`);
+        return new AbstractType.JsonType(code `${this.name}.Json`);
     }
     jsonUiSchemaElement({ variables, }) {
-        return Maybe.of(code `${this.name}.${syntheticNamePrefix}Json.uiSchema({ scopePrefix: ${variables.scopePrefix} })`);
+        return Maybe.of(code `${this.name}.Json.uiSchema({ scopePrefix: ${variables.scopePrefix} })`);
     }
     toJsonExpression({ variables, }) {
-        return code `${this.name}.${syntheticNamePrefix}toJson(${variables.value})`;
+        return code `${this.name}.toJson(${variables.value})`;
     }
     toStringExpression({ variables, }) {
         return code `${this.name}.${syntheticNamePrefix}toString(${variables.value})`;
     }
     toRdfResourceValuesExpression({ variables, }) {
-        return code `[${this.name}.${syntheticNamePrefix}toRdfResource(${variables.value}, { graph: ${variables.graph}, resourceSet: ${variables.resourceSet} }).identifier]`;
+        return code `[${this.name}.toRdfResource(${variables.value}, { graph: ${variables.graph}, resourceSet: ${variables.resourceSet} }).identifier]`;
     }
     lazyAncestorObjectTypes;
     lazyChildObjectTypes;

package/dist/generators/ts/NamedObjectUnionType.js

@@ -13,9 +13,7 @@ import { NamedObjectType_sparqlConstructQueryFunctionDeclaration } from "./_Name
 import { NamedObjectType_sparqlConstructQueryStringFunctionDeclaration } from "./_NamedObjectType/NamedObjectType_sparqlConstructQueryStringFunctionDeclaration.js";
 import { AbstractNamedUnionType } from "./AbstractNamedUnionType.js";
 import { AbstractType } from "./AbstractType.js";
-import { imports } from "./imports.js";
 import { singleEntryRecord } from "./singleEntryRecord.js";
-import { snippets } from "./snippets.js";
 import { syntheticNamePrefix } from "./syntheticNamePrefix.js";
 import { code, joinCode, literalOf } from "./ts-poet-wrapper.js";
 export class NamedObjectUnionType extends AbstractNamedUnionType {
@@ -27,16 +25,16 @@ export class NamedObjectUnionType extends AbstractNamedUnionType {
         this.#identifierType = identifierType;
     }
     get graphqlType() {
-        return new AbstractType.GraphqlType(code `${this._name}.${syntheticNamePrefix}GraphQL`);
+        return new AbstractType.GraphqlType(code `${this._name}.GraphQL`, this.reusables);
     }
     get identifierTypeAlias() {
-        return code `${this.name}.${syntheticNamePrefix}Identifier`;
+        return code `${this.name}.Identifier`;
     }
     get objectSetMethodNames() {
         return NamedObjectType_objectSetMethodNames.call(this);
     }
     get schema() {
-        return code `${this.name}.${syntheticNamePrefix}schema`;
+        return code `${this.name}.schema`;
     }
     get schemaType() {
         return code `typeof ${this.schema}`;
@@ -51,11 +49,21 @@ export class NamedObjectUnionType extends AbstractNamedUnionType {
             ...this.graphqlTypeVariableStatement,
             ...this.isTypeFunctionDeclaration,
             ...this.schemaVariableStatement,
-            ...NamedObjectType_sparqlConstructQueryFunctionDeclaration.call(this)
-                .map((code_) => singleEntryRecord(`${syntheticNamePrefix}sparqlConstructQuery`, code_))
+            ...NamedObjectType_sparqlConstructQueryFunctionDeclaration.call({
+                features: this.features,
+                filterType: this.filterType,
+                name: this.name,
+                reusables: this.reusables,
+            })
+                .map((code_) => singleEntryRecord(`sparqlConstructQuery`, code_))
                 .orDefault({}),
-            ...NamedObjectType_sparqlConstructQueryStringFunctionDeclaration.call(this)
-                .map((code_) => singleEntryRecord(`${syntheticNamePrefix}sparqlConstructQueryString`, code_))
+            ...NamedObjectType_sparqlConstructQueryStringFunctionDeclaration.call({
+                features: this.features,
+                filterType: this.filterType,
+                name: this.name,
+                reusables: this.reusables,
+            })
+                .map((code_) => singleEntryRecord(`sparqlConstructQueryString`, code_))
                 .orDefault({}),
             ...this.toRdfResourceFunctionDeclaration,
         };
@@ -64,19 +72,19 @@ export class NamedObjectUnionType extends AbstractNamedUnionType {
         if (!this.features.has("sparql")) {
             return {};
         }
-        return singleEntryRecord(`${syntheticNamePrefix}focusSparqlConstructTriples`, code `\
-export function ${syntheticNamePrefix}focusSparqlConstructTriples({ filter, focusIdentifier, variablePrefix }: { filter: ${this.filterType} | undefined; focusIdentifier: ${imports.NamedNode} | ${imports.Variable}; ignoreRdfType: boolean; variablePrefix: string }): readonly ${imports.sparqljs}.Triple[] {
-  return [${joinCode(this.members.map((member) => code `...${member.type.name}.${syntheticNamePrefix}focusSparqlConstructTriples({ filter: filter?.on?.${member.type.name}, focusIdentifier, ignoreRdfType: false, variablePrefix: \`\${variablePrefix}${pascalCase(member.type.name)}\` }).concat()`), { on: ", " })}];
+        return singleEntryRecord(`focusSparqlConstructTriples`, code `\
+export function focusSparqlConstructTriples({ filter, focusIdentifier, variablePrefix }: { filter: ${this.filterType} | undefined; focusIdentifier: ${this.reusables.imports.NamedNode} | ${this.reusables.imports.Variable}; ignoreRdfType: boolean; variablePrefix: string }): readonly ${this.reusables.imports.sparqljs}.Triple[] {
+  return [${joinCode(this.members.map((member) => code `...${member.type.name}.focusSparqlConstructTriples({ filter: filter?.on?.${member.type.name}, focusIdentifier, ignoreRdfType: false, variablePrefix: \`\${variablePrefix}${pascalCase(member.type.name)}\` }).concat()`), { on: ", " })}];
 }`);
     }
     get focusSparqlWherePatternsFunctionDeclaration() {
         if (!this.features.has("sparql")) {
             return {};
         }
-        return singleEntryRecord(`${syntheticNamePrefix}focusSparqlWherePatterns`, code `\
-export function ${syntheticNamePrefix}focusSparqlWherePatterns({ filter, focusIdentifier, preferredLanguages, variablePrefix }: { filter: ${this.filterType} | undefined; focusIdentifier: ${imports.NamedNode} | ${imports.Variable}; ignoreRdfType: boolean; preferredLanguages: readonly string[] | undefined; variablePrefix: string }): readonly ${snippets.SparqlPattern}[] {
+        return singleEntryRecord(`focusSparqlWherePatterns`, code `\
+export function focusSparqlWherePatterns({ filter, focusIdentifier, preferredLanguages, variablePrefix }: { filter: ${this.filterType} | undefined; focusIdentifier: ${this.reusables.imports.NamedNode} | ${this.reusables.imports.Variable}; ignoreRdfType: boolean; preferredLanguages: readonly string[] | undefined; variablePrefix: string }): readonly ${this.reusables.snippets.SparqlPattern}[] {
 ${joinCode([
-            code `let patterns: ${snippets.SparqlPattern}[] = [];`,
+            code `let patterns: ${this.reusables.snippets.SparqlPattern}[] = [];`,
             code `\
 if (focusIdentifier.termType === "Variable") {
   patterns = patterns.concat(${this.#identifierType.valueSparqlWherePatternsFunction}({
@@ -90,7 +98,7 @@ if (focusIdentifier.termType === "Variable") {
   }));
 }`,
             code `patterns.push({ patterns: [${joinCode(this.members.map((member) => code `${{
-                patterns: code `${member.type.name}.${syntheticNamePrefix}focusSparqlWherePatterns({ filter: filter?.on?.${member.type.name}, focusIdentifier, ignoreRdfType: false, preferredLanguages, variablePrefix: \`\${variablePrefix}${pascalCase(member.type.name)}\` }).concat()`,
+                patterns: code `${member.type.name}.focusSparqlWherePatterns({ filter: filter?.on?.${member.type.name}, focusIdentifier, ignoreRdfType: false, preferredLanguages, variablePrefix: \`\${variablePrefix}${pascalCase(member.type.name)}\` }).concat()`,
                 type: literalOf("group"),
             }}`), { on: ", " })}], type: "union" });`,
             code `return patterns;`,
@@ -101,10 +109,10 @@ if (focusIdentifier.termType === "Variable") {
         if (!this.features.has("rdf")) {
             return {};
         }
-        return singleEntryRecord(`${syntheticNamePrefix}fromRdfResource`, code `\
-export const ${syntheticNamePrefix}fromRdfResource: ${snippets.FromRdfResourceFunction}<${this.name}> = (resource, options) => 
+        return singleEntryRecord(`fromRdfResource`, code `\
+export const fromRdfResource: ${this.reusables.snippets.FromRdfResourceFunction}<${this.name}> = (resource, options) => 
   ${this.members.reduce((expression, member) => {
-            const memberTypeExpression = code `(${member.type.name}.${syntheticNamePrefix}fromRdfResource(resource, { ...options, ignoreRdfType: false }) as ${imports.Either}<Error, ${this.name}>)`;
+            const memberTypeExpression = code `(${member.type.name}.fromRdfResource(resource, { ...options, ignoreRdfType: false }) as ${this.reusables.imports.Either}<Error, ${this.name}>)`;
             return expression !== null
                 ? code `${expression}.altLazy(() => ${memberTypeExpression})`
                 : memberTypeExpression;
@@ -114,8 +122,8 @@ export const ${syntheticNamePrefix}fromRdfResource: ${snippets.FromRdfResourceFu
         if (!this.features.has("graphql")) {
             return {};
         }
-        return singleEntryRecord(`${syntheticNamePrefix}GraphQL`, code `\
-export const ${syntheticNamePrefix}GraphQL = new ${imports.GraphQLUnionType}(${{
+        return singleEntryRecord(`GraphQL`, code `\
+export const GraphQL = new ${this.reusables.imports.GraphQLUnionType}(${{
             description: this.comment.map(JSON.stringify).extract(),
             name: this.name,
             resolveType: code `(value: ${this.name}) => value.${syntheticNamePrefix}type`,
@@ -123,9 +131,9 @@ export const ${syntheticNamePrefix}GraphQL = new ${imports.GraphQLUnionType}(${{
         }});`);
     }
     get identifierTypeDeclarations() {
-        return singleEntryRecord(`${syntheticNamePrefix}Identifier`, code `\
-export type ${syntheticNamePrefix}Identifier = ${this.#identifierType.name};
-export namespace ${syntheticNamePrefix}Identifier {
+        return singleEntryRecord(`Identifier`, code `\
+export type Identifier = ${this.#identifierType.name};
+export namespace Identifier {
   export const parse = ${this.#identifierType.parseFunction};
   export const stringify = ${this.#identifierType.stringifyFunction};
 }`);
@@ -169,8 +177,8 @@ export namespace ${syntheticNamePrefix}Identifier {
             }
             propertiesObject.push(code `${property.name}: ${property.schema}`);
         }
-        return singleEntryRecord(`${syntheticNamePrefix}schema`, code `\
-export const ${syntheticNamePrefix}schema =
+        return singleEntryRecord(`schema`, code `\
+export const schema =
 ${{
             ...super.schemaObject,
             properties: code `{ ${joinCode(propertiesObject, { on: ", " })} }`,
@@ -180,10 +188,10 @@ ${{
         if (!this.features.has("rdf")) {
             return {};
         }
-        return singleEntryRecord(`${syntheticNamePrefix}toRdfResource`, code `\
-export const ${syntheticNamePrefix}toRdfResource: ${snippets.ToRdfResourceFunction}<${this.name}> = (value, options) => {
+        return singleEntryRecord(`toRdfResource`, code `\
+export const toRdfResource: ${this.reusables.snippets.ToRdfResourceFunction}<${this.name}> = (value, options) => {
 ${joinCode(this.members
-            .map((member) => code `if (${member.type.name}.is${member.type.name}(value)) { return ${member.type.name}.${syntheticNamePrefix}toRdfResource(value, options); }`)
+            .map((member) => code `if (${member.type.name}.is${member.type.name}(value)) { return ${member.type.name}.toRdfResource(value, options); }`)
             .concat(code `throw new Error("unrecognized type");`))}
 };`);
     }

package/dist/generators/ts/OptionType.js

@@ -10,8 +10,6 @@ import { Memoize } from "typescript-memoize";
 import { AbstractCollectionType } from "./AbstractCollectionType.js";
 import { AbstractContainerType } from "./AbstractContainerType.js";
 import { codeEquals } from "./codeEquals.js";
-import { imports } from "./imports.js";
-import { snippets } from "./snippets.js";
 import { code, joinCode, literalOf } from "./ts-poet-wrapper.js";
 export class OptionType extends AbstractContainerType {
     discriminantProperty = Maybe.empty();
@@ -22,14 +20,14 @@ export class OptionType extends AbstractContainerType {
         const conversions = [];
         conversions.push({
             conversionExpression: (value) => value,
-            sourceTypeCheckExpression: (value) => code `${imports.Maybe}.isMaybe(${value})`,
+            sourceTypeCheckExpression: (value) => code `${this.reusables.imports.Maybe}.isMaybe(${value})`,
             sourceTypeName: this.name,
             sourceTypeof: "object",
         });
         for (const itemTypeConversion of this.itemType.conversions) {
             conversions.push({
                 ...itemTypeConversion,
-                conversionExpression: (value) => code `${imports.Maybe}.of(${itemTypeConversion.conversionExpression(value)})`,
+                conversionExpression: (value) => code `${this.reusables.imports.Maybe}.of(${itemTypeConversion.conversionExpression(value)})`,
             });
         }
         // Unless itemType is a list, it should only have a conversion from undefined if it has a
@@ -38,7 +36,7 @@ export class OptionType extends AbstractContainerType {
         invariant(!conversions.some((conversion) => conversion.sourceTypeof === "undefined") || this.itemType instanceof AbstractCollectionType);
         if (!conversions.some((conversion) => conversion.sourceTypeof === "undefined")) {
             conversions.push({
-                conversionExpression: () => code `${imports.Maybe}.empty()`,
+                conversionExpression: () => code `${this.reusables.imports.Maybe}.empty()`,
                 sourceTypeCheckExpression: (value) => code `${value} === undefined`,
                 sourceTypeName: code `undefined`,
                 sourceTypeof: "undefined",
@@ -47,17 +45,17 @@ export class OptionType extends AbstractContainerType {
         return conversions;
     }
     get equalsFunction() {
-        return code `((left, right) => ${snippets.maybeEquals}(left, right, ${this.itemType.equalsFunction}))`;
+        return code `((left, right) => ${this.reusables.snippets.maybeEquals}(left, right, ${this.itemType.equalsFunction}))`;
     }
     get filterFunction() {
-        return code `${snippets.filterMaybe}<${this.itemType.name}, ${this.itemType.filterType}>(${this.itemType.filterFunction})`;
+        return code `${this.reusables.snippets.filterMaybe}<${this.itemType.name}, ${this.itemType.filterType}>(${this.itemType.filterFunction})`;
     }
     get filterType() {
-        return code `${snippets.MaybeFilter}<${this.itemType.filterType}>`;
+        return code `${this.reusables.snippets.MaybeFilter}<${this.itemType.filterType}>`;
     }
     get graphqlType() {
         invariant(!this.itemType.graphqlType.nullable);
-        return new AbstractContainerType.GraphqlType(this.itemType.graphqlType.name, {
+        return new AbstractContainerType.GraphqlType(this.itemType.graphqlType.name, this.reusables, {
             nullable: true,
         });
     }
@@ -65,16 +63,16 @@ export class OptionType extends AbstractContainerType {
         return this.itemType.mutable;
     }
     get name() {
-        return code `${imports.Maybe}<${this.itemType.name}>`;
+        return code `${this.reusables.imports.Maybe}<${this.itemType.name}>`;
     }
     get schemaType() {
-        return code `${snippets.MaybeSchema}<${this.itemType.schemaType}>`;
+        return code `${this.reusables.snippets.MaybeSchema}<${this.itemType.schemaType}>`;
     }
     get valueSparqlConstructTriplesFunction() {
-        return code `${snippets.maybeSparqlConstructTriples}<${this.itemType.filterType}, ${this.itemType.schemaType}>(${this.itemType.valueSparqlConstructTriplesFunction})`;
+        return code `${this.reusables.snippets.maybeSparqlConstructTriples}<${this.itemType.filterType}, ${this.itemType.schemaType}>(${this.itemType.valueSparqlConstructTriplesFunction})`;
     }
     get valueSparqlWherePatternsFunction() {
-        return code `${snippets.maybeSparqlWherePatterns}<${this.itemType.filterType}, ${this.itemType.schemaType}>(${this.itemType.valueSparqlWherePatternsFunction})`;
+        return code `${this.reusables.snippets.maybeSparqlWherePatterns}<${this.itemType.filterType}, ${this.itemType.schemaType}>(${this.itemType.valueSparqlWherePatternsFunction})`;
     }
     get schemaObject() {
         return {
@@ -83,7 +81,7 @@ export class OptionType extends AbstractContainerType {
         };
     }
     fromJsonExpression({ variables, }) {
-        const expression = code `${imports.Maybe}.fromNullable(${variables.value})`;
+        const expression = code `${this.reusables.imports.Maybe}.fromNullable(${variables.value})`;
         const valueVariable = code `item`;
         const itemFromJsonExpression = this.itemType.fromJsonExpression({
             variables: { value: valueVariable },
@@ -94,7 +92,7 @@ export class OptionType extends AbstractContainerType {
     }
     fromRdfResourceValuesExpression(parameters) {
         const { variables } = parameters;
-        return code `${this.itemType.fromRdfResourceValuesExpression(parameters)}.map(values => values.length > 0 ? values.map(value => ${imports.Maybe}.of(value)) : ${imports.Resource}.Values.fromValue<${imports.Maybe}<${this.itemType.name}>>({ focusResource: ${variables.resource}, propertyPath: ${variables.propertyPath}, value: ${imports.Maybe}.empty() }))`;
+        return code `${this.itemType.fromRdfResourceValuesExpression(parameters)}.map(values => values.length > 0 ? values.map(value => ${this.reusables.imports.Maybe}.of(value)) : ${this.reusables.imports.Resource}.Values.fromValue<${this.reusables.imports.Maybe}<${this.itemType.name}>>({ focusResource: ${variables.resource}, propertyPath: ${variables.propertyPath}, value: ${this.reusables.imports.Maybe}.empty() }))`;
     }
     graphqlResolveExpression(parameters) {
         return code `${this.itemType.graphqlResolveExpression(parameters)}.extractNullable()`;

package/dist/generators/ts/Reusables.d.ts

@@ -0,0 +1,11 @@
+import type { Logger } from "ts-log";
+import { Imports } from "./Imports.js";
+import { Snippets } from "./Snippets.js";
+export declare class Reusables {
+    readonly imports: Imports;
+    readonly snippets: Snippets;
+    constructor({ logger }: {
+        logger: Logger;
+    });
+}
+//# sourceMappingURL=Reusables.d.ts.map

package/dist/generators/ts/Reusables.js

@@ -0,0 +1,14 @@
+import { Imports } from "./Imports.js";
+import { Snippets } from "./Snippets.js";
+export class Reusables {
+    imports;
+    snippets;
+    constructor({ logger }) {
+        this.imports = new Imports();
+        this.snippets = new Snippets({
+            imports: this.imports,
+            logger,
+        });
+    }
+}
+//# sourceMappingURL=Reusables.js.map

package/dist/generators/ts/SetType.js

@@ -7,8 +7,6 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 import { Maybe } from "purify-ts";
 import { Memoize } from "typescript-memoize";
 import { AbstractCollectionType } from "./AbstractCollectionType.js";
-import { imports } from "./imports.js";
-import { snippets } from "./snippets.js";
 import { code, joinCode } from "./ts-poet-wrapper.js";
 export class SetType extends AbstractCollectionType {
     graphqlArgs = Maybe.empty();
@@ -26,10 +24,10 @@ export class SetType extends AbstractCollectionType {
         return conversions.concat(super.conversions);
     }
     get valueSparqlConstructTriplesFunction() {
-        return code `${snippets.setSparqlConstructTriples}<${this.itemType.filterType}, ${this.itemType.schemaType}>(${this.itemType.valueSparqlConstructTriplesFunction})`;
+        return code `${this.reusables.snippets.setSparqlConstructTriples}<${this.itemType.filterType}, ${this.itemType.schemaType}>(${this.itemType.valueSparqlConstructTriplesFunction})`;
     }
     get valueSparqlWherePatternsFunction() {
-        return code `${snippets.setSparqlWherePatterns}<${this.itemType.filterType}, ${this.itemType.schemaType}>(${this.itemType.valueSparqlWherePatternsFunction})`;
+        return code `${this.reusables.snippets.setSparqlWherePatterns}<${this.itemType.filterType}, ${this.itemType.schemaType}>(${this.itemType.valueSparqlWherePatternsFunction})`;
     }
     fromRdfResourceValuesExpression(parameters) {
         const { variables } = parameters;
@@ -40,9 +38,9 @@ export class SetType extends AbstractCollectionType {
             chain.push(code `map(values => values.toArray()${this._mutable ? ".concat()" : ""})`);
         }
         else {
-            chain.push(code `chain(values => ${imports.NonEmptyList}.fromArray(values.toArray()).toEither(new Error(\`\${${variables.resource}.identifier} is an empty set\`)))`);
+            chain.push(code `chain(values => ${this.reusables.imports.NonEmptyList}.fromArray(values.toArray()).toEither(new Error(\`\${${variables.resource}.identifier} is an empty set\`)))`);
         }
-        chain.push(code `map(valuesArray => ${imports.Resource}.Values.fromValue({ focusResource: ${variables.resource}, propertyPath: ${variables.propertyPath}, value: valuesArray }))`);
+        chain.push(code `map(valuesArray => ${this.reusables.imports.Resource}.Values.fromValue({ focusResource: ${variables.resource}, propertyPath: ${variables.propertyPath}, value: valuesArray }))`);
         return joinCode(chain, { on: "." });
     }
     jsonType() {

package/dist/generators/ts/Snippet.d.ts

@@ -0,0 +1,3 @@
+import type { conditionalOutput } from "./ts-poet-wrapper.js";
+export type Snippet = ReturnType<typeof conditionalOutput>;
+//# sourceMappingURL=Snippet.d.ts.map

package/dist/generators/ts/Snippet.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=Snippet.js.map