@shaclmate/compiler 4.0.29 → 4.0.31

package/dist/generators/ts/LazyObjectType.d.ts

@@ -3,8 +3,12 @@ import { type Code } from "./ts-poet-wrapper.js";
 export declare class LazyObjectType extends AbstractLazyObjectType<AbstractLazyObjectType.ObjectTypeConstraint, AbstractLazyObjectType.ObjectTypeConstraint> {
     readonly graphqlArgs: Super["graphqlArgs"];
     readonly kind = "LazyObjectType";
-    constructor({ partialType, resolveType, ...superParameters }: Omit<ConstructorParameters<typeof AbstractLazyObjectType<AbstractLazyObjectType.ObjectTypeConstraint, AbstractLazyObjectType.ObjectTypeConstraint>>[0], "runtimeClass">);
     get conversions(): readonly AbstractLazyObjectType.Conversion[];
+    protected get runtimeClass(): {
+        name: Code;
+        partialPropertyName: string;
+        rawName: Code;
+    };
     fromJsonExpression(parameters: Parameters<Super["fromJsonExpression"]>[0]): Code;
     fromRdfResourceValuesExpression(parameters: Parameters<Super["fromRdfResourceValuesExpression"]>[0]): Code;
     graphqlResolveExpression({ variables, }: Parameters<Super["graphqlResolveExpression"]>[0]): Code;

package/dist/generators/ts/LazyObjectType.js

@@ -1,29 +1,21 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
 import { Maybe } from "purify-ts";
+import { Memoize } from "typescript-memoize";
 import { AbstractLazyObjectType } from "./AbstractLazyObjectType.js";
-import { imports } from "./imports.js";
-import { snippets } from "./snippets.js";
-import { syntheticNamePrefix } from "./syntheticNamePrefix.js";
 import { code } from "./ts-poet-wrapper.js";
 export class LazyObjectType extends AbstractLazyObjectType {
     graphqlArgs = Maybe.empty();
     kind = "LazyObjectType";
-    constructor({ partialType, resolveType, ...superParameters }) {
-        super({
-            ...superParameters,
-            partialType,
-            resolveType,
-            runtimeClass: {
-                name: code `${snippets.LazyObject}<${resolveType.identifierTypeAlias}, ${partialType.name}, ${resolveType.name}>`,
-                partialPropertyName: "partial",
-                rawName: code `${snippets.LazyObject}`,
-            },
-        });
-    }
     get conversions() {
         const conversions = super.conversions.concat();
         if (this.partialType.kind === "NamedObjectType") {
             conversions.push({
-                conversionExpression: (value) => code `new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}: ${this.partialType.name}.${syntheticNamePrefix}create(${value}), resolver: async () => ${imports.Right}(${value} as ${this.resolveType.name}) })`,
+                conversionExpression: (value) => code `new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}: ${this.partialType.name}.create(${value}), resolver: async () => ${this.reusables.imports.Right}(${value} as ${this.resolveType.name}) })`,
                 // Don't check instanceof value since the NamedObjectType may be an interface
                 // Rely on the fact that this will be the last type check on an object
                 sourceTypeCheckExpression: (value) => code `typeof ${value} === "object"`,
@@ -35,7 +27,7 @@ export class LazyObjectType extends AbstractLazyObjectType {
             this.partialType.kind === "NamedObjectUnionType" &&
             this.resolveType.members.length === this.partialType.members.length) {
             conversions.push({
-                conversionExpression: (value) => code `new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}: ((object: ${this.resolveType.name}) => { ${this.resolvedNamedObjectUnionTypeToPartialNamedObjectUnionTypeConversion({ resolvedNamedObjectUnionType: this.resolveType, partialNamedObjectUnionType: this.partialType, variables: { resolvedObjectUnion: code `object` } })} })(${value}), resolver: async () => ${imports.Right}(${value} as ${this.resolveType.name}) })`,
+                conversionExpression: (value) => code `new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}: ((object: ${this.resolveType.name}) => { ${this.resolvedNamedObjectUnionTypeToPartialNamedObjectUnionTypeConversion({ resolvedNamedObjectUnionType: this.resolveType, partialNamedObjectUnionType: this.partialType, variables: { resolvedObjectUnion: code `object` } })} })(${value}), resolver: async () => ${this.reusables.imports.Right}(${value} as ${this.resolveType.name}) })`,
                 // Don't check instanceof value since the NamedObjectUnionType may be an interface
                 // Rely on the fact that this will be the last type check on an object
                 sourceTypeCheckExpression: (value) => code `typeof ${value} === "object"`,
@@ -45,8 +37,15 @@ export class LazyObjectType extends AbstractLazyObjectType {
         }
         return conversions;
     }
+    get runtimeClass() {
+        return {
+            name: code `${this.reusables.snippets.LazyObject}<${this.resolveType.identifierTypeAlias}, ${this.partialType.name}, ${this.resolveType.name}>`,
+            partialPropertyName: "partial",
+            rawName: code `${this.reusables.snippets.LazyObject}`,
+        };
+    }
     fromJsonExpression(parameters) {
-        return code `new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}: ${this.partialType.fromJsonExpression(parameters)}, resolver: (identifier) => Promise.resolve(${imports.Left}(new Error(\`unable to resolve identifier \${identifier} deserialized from JSON\`))) })`;
+        return code `new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}: ${this.partialType.fromJsonExpression(parameters)}, resolver: (identifier) => Promise.resolve(${this.reusables.imports.Left}(new Error(\`unable to resolve identifier \${identifier} deserialized from JSON\`))) })`;
     }
     fromRdfResourceValuesExpression(parameters) {
         const { variables } = parameters;
@@ -56,4 +55,7 @@ export class LazyObjectType extends AbstractLazyObjectType {
         return code `${variables.value}.resolve().then(either => either.unsafeCoerce())`;
     }
 }
+__decorate([
+    Memoize()
+], LazyObjectType.prototype, "runtimeClass", null);
 //# sourceMappingURL=LazyObjectType.js.map

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,28 +63,28 @@ 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 };
   },
   {
     currentSubListResource: null,
-    listResource: resourceSet.resource(${mintListIdentifierFunction}()),
+    listResource: ${variables.resourceSet}.resource(${mintListIdentifierFunction}()),
   } as {
     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

@@ -30,8 +30,6 @@ import { NamedObjectType_jsonSchemaFunctionDeclaration } from "./_NamedObjectTyp
 import { NamedObjectType_jsonTypeAliasDeclaration } from "./_NamedObjectType/NamedObjectType_jsonTypeAliasDeclaration.js";
 import { NamedObjectType_jsonUiSchemaFunctionDeclaration } from "./_NamedObjectType/NamedObjectType_jsonUiSchemaFunctionDeclaration.js";
 import { NamedObjectType_objectSetMethodNames } from "./_NamedObjectType/NamedObjectType_objectSetMethodNames.js";
-import { NamedObjectType_propertiesFromJsonFunctionDeclaration } from "./_NamedObjectType/NamedObjectType_propertiesFromJsonFunctionDeclaration.js";
-import { NamedObjectType_propertiesFromRdfResourceFunctionDeclaration } from "./_NamedObjectType/NamedObjectType_propertiesFromRdfResourceFunctionDeclaration.js";
 import { NamedObjectType_schemaVariableStatement } from "./_NamedObjectType/NamedObjectType_schemaVariableStatement.js";
 import { NamedObjectType_sparqlConstructQueryFunctionDeclaration } from "./_NamedObjectType/NamedObjectType_sparqlConstructQueryFunctionDeclaration.js";
 import { NamedObjectType_sparqlConstructQueryStringFunctionDeclaration } from "./_NamedObjectType/NamedObjectType_sparqlConstructQueryStringFunctionDeclaration.js";
@@ -42,11 +40,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 +54,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 +93,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 +104,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_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)} {
@@ -135,6 +137,7 @@ ${joinCode(staticModuleDeclarations, { on: "\n\n" })}
     }
     get discriminantProperty() {
         return Maybe.of({
+            jsonName: this._discriminantProperty.jsonName,
             name: this._discriminantProperty.name,
             ownValues: this._discriminantProperty.type.ownValues,
             descendantValues: this._discriminantProperty.type.descendantValues,
@@ -144,22 +147,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 +184,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 +196,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}> = (object, 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}(object)) { return ${member.type.name}.toRdfResource(object, options); }`)
             .concat(code `throw new Error("unrecognized type");`))}
 };`);
     }