@shaclmate/compiler 4.0.36 → 4.0.38

package/dist/generators/ts/{sparqlObjectSetClassDeclaration.js → SparqlObjectSetType.js}

@@ -1,23 +1,31 @@
-import { objectSetMethodSignatures } from "./objectSetMethodSignatures.js";
+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 { Memoize } from "typescript-memoize";
+import { AbstractObjectSetType } from "./AbstractObjectSetType.js";
 import { code, joinCode } from "./ts-poet-wrapper.js";
-export function sparqlObjectSetClassDeclaration({ namedObjectTypes, namedObjectUnionTypes, }) {
-    const syntheticNamePrefix = this.configuration.syntheticNamePrefix;
-    const parameters = {
-        constructObjectType: code `namedObjectType: {\
+export class SparqlObjectSetType extends AbstractObjectSetType {
+    get declaration() {
+        const syntheticNamePrefix = this.configuration.syntheticNamePrefix;
+        const parameters = {
+            constructObjectType: code `namedObjectType: {\
   focusSparqlWherePatterns: ${this.reusables.snippets.FocusSparqlWherePatternsFunction}<ObjectFilterT>;
   fromRdfResource:  ${this.reusables.snippets.FromRdfResourceFunction}<ObjectT>;
   sparqlConstructQueryString: (parameters: { filter?: ObjectFilterT; subject: ${this.reusables.imports.NamedNode} | ${this.reusables.imports.Variable}; } & Omit<${this.reusables.imports.sparqljs}.ConstructQuery, "prefixes" | "queryType" | "type"> & ${this.reusables.imports.sparqljs}.GeneratorOptions) => string;
 }`,
-        query: code `query?: ${syntheticNamePrefix}SparqlObjectSet.Query<ObjectFilterT, ObjectIdentifierT>`,
-        selectObjectTypeType: code `namedObjectType: { focusSparqlWherePatterns: ${this.reusables.snippets.FocusSparqlWherePatternsFunction}<ObjectFilterT> }`,
-    };
-    const sparqlClientType = code `{ queryBindings: (query: string) => Promise<readonly Record<string, ${this.reusables.imports.BlankNode} | ${this.reusables.imports.Literal} | ${this.reusables.imports.NamedNode}>[]>; queryQuads: (query: string) => Promise<readonly ${this.reusables.imports.Quad}[]>; }`;
-    const typeParameters = {
-        ObjectT: code `ObjectT extends { readonly $identifier: () => ObjectIdentifierT }`,
-        ObjectFilterT: code `ObjectFilterT`,
-        ObjectIdentifierT: code `ObjectIdentifierT extends ${this.reusables.imports.BlankNode} | ${this.reusables.imports.NamedNode}`,
-    };
-    return code `\
+            query: code `query?: ${syntheticNamePrefix}SparqlObjectSet.Query<ObjectFilterT, ObjectIdentifierT>`,
+            selectObjectTypeType: code `namedObjectType: { focusSparqlWherePatterns: ${this.reusables.snippets.FocusSparqlWherePatternsFunction}<ObjectFilterT> }`,
+        };
+        const sparqlClientType = code `{ queryBindings: (query: string) => Promise<readonly Record<string, ${this.reusables.imports.BlankNode} | ${this.reusables.imports.Literal} | ${this.reusables.imports.NamedNode}>[]>; queryQuads: (query: string) => Promise<readonly ${this.reusables.imports.Quad}[]>; }`;
+        const typeParameters = {
+            ObjectT: code `ObjectT extends { readonly $identifier: () => ObjectIdentifierT }`,
+            ObjectFilterT: code `ObjectFilterT`,
+            ObjectIdentifierT: code `ObjectIdentifierT extends ${this.reusables.imports.BlankNode} | ${this.reusables.imports.NamedNode}`,
+        };
+        return code `\
 export class ${syntheticNamePrefix}SparqlObjectSet implements ${syntheticNamePrefix}ObjectSet {
   readonly #countVariable = ${this.reusables.imports.dataFactory}.variable!("count");;
   readonly #graph?: Exclude<${this.reusables.imports.Quad_Graph}, ${this.reusables.imports.Variable}>;
@@ -30,31 +38,30 @@ export class ${syntheticNamePrefix}SparqlObjectSet implements ${syntheticNamePre
     this.#sparqlClient = sparqlClient;
   }
 
-${joinCode([...namedObjectTypes, ...namedObjectUnionTypes].flatMap((namedObjectType) => {
-        const methodSignatures = objectSetMethodSignatures.call(this, {
-            namedObjectType,
-            queryT: `${syntheticNamePrefix}SparqlObjectSet.Query`,
-        });
-        const runtimeObjectType = namedObjectType.name;
-        return [
-            code `\
+${joinCode([...this.namedObjectTypes, ...this.namedObjectUnionTypes].flatMap((namedObjectType) => {
+            const methodSignatures = this.methodSignatures(namedObjectType, {
+                queryT: `${syntheticNamePrefix}SparqlObjectSet.Query`,
+            });
+            const runtimeObjectType = namedObjectType.name;
+            return [
+                code `\
 async ${methodSignatures.object.name}(${methodSignatures.object.parameters}): ${methodSignatures.object.returnType} {
   return (await this.${methodSignatures.objects.name}({ identifiers: [identifier], preferredLanguages: options?.preferredLanguages })).map(objects => objects[0]);
 }`,
-            code `\
+                code `\
 async ${methodSignatures.objectCount.name}(${methodSignatures.objectCount.parameters}): ${methodSignatures.objectCount.returnType} {
   return this.#objectCount<${namedObjectType.filterType}, ${namedObjectType.identifierTypeAlias}>(${runtimeObjectType}, query);
 }`,
-            code `\
+                code `\
 async ${methodSignatures.objectIdentifiers.name}(${methodSignatures.objectIdentifiers.parameters}): ${methodSignatures.objectIdentifiers.returnType} {
   return this.#objectIdentifiers<${namedObjectType.filterType}, ${namedObjectType.identifierTypeAlias}>(${runtimeObjectType}, query);
 }`,
-            code `\
+                code `\
 async ${methodSignatures.objects.name}(${methodSignatures.objects.parameters}): ${methodSignatures.objects.returnType} {
   return this.#objects<${namedObjectType.name}, ${namedObjectType.filterType}, ${namedObjectType.identifierTypeAlias}>(${runtimeObjectType}, query);
 }`,
-        ];
-    }), { on: "\n\n" })}
+            ];
+        }), { on: "\n\n" })}
 
   #mapBindingsToCount(bindings: readonly Record<string, ${this.reusables.imports.BlankNode} | ${this.reusables.imports.Literal} | ${this.reusables.imports.NamedNode}>[], variable: string): ${this.reusables.imports.Either}<Error, number> {
     if (bindings.length === 0) {
@@ -226,5 +233,9 @@ async ${methodSignatures.objects.name}(${methodSignatures.objects.parameters}):
 export namespace ${syntheticNamePrefix}SparqlObjectSet {
   export type Query<${typeParameters.ObjectFilterT}, ${typeParameters.ObjectIdentifierT}> = ${syntheticNamePrefix}ObjectSet.Query<ObjectFilterT, ObjectIdentifierT> & { readonly order?: (objectVariable: ${this.reusables.imports.Variable}) => readonly ${this.reusables.imports.sparqljs}.Ordering[]; readonly where?: (objectVariable: ${this.reusables.imports.Variable}) => readonly ${this.reusables.imports.sparqljs}.Pattern[] };
 }`;
+    }
 }
-//# sourceMappingURL=sparqlObjectSetClassDeclaration.js.map
+__decorate([
+    Memoize()
+], SparqlObjectSetType.prototype, "declaration", null);
+//# sourceMappingURL=SparqlObjectSetType.js.map

package/dist/generators/ts/TsGenerator.d.ts

@@ -1,18 +1,16 @@
 import type { Logger } from "ts-log";
 import * as ast from "../../ast/index.js";
 import type { Generator } from "../Generator.js";
-import { Reusables } from "./Reusables.js";
 import type { TsFeature } from "./TsFeature.js";
 export declare class TsGenerator implements Generator {
-    private readonly typeFactory;
-    protected readonly configuration: TsGenerator.Configuration;
-    protected readonly logger: Logger;
-    protected readonly reusables: Reusables;
+    private readonly configuration?;
+    private readonly logger;
     constructor({ configuration, logger, }: {
-        configuration?: TsGenerator.Configuration;
+        configuration?: Partial<TsGenerator.Configuration>;
         logger: Logger;
     });
     generate(ast_: ast.Ast): string;
+    private objectSetTypeDeclarations;
     /**
      * Synthesize the $Object union.
      */
@@ -21,11 +19,12 @@ export declare class TsGenerator implements Generator {
 export declare namespace TsGenerator {
     interface Configuration {
         readonly features: ReadonlySet<TsFeature>;
+        readonly finalized: true;
         readonly syntheticNamePrefix: string;
     }
     namespace Configuration {
-        function inferFeatures(features: ReadonlySet<TsFeature>): Set<"JSON" | "GraphQL" | "Object.create" | "Object.equals" | "Object.filter" | "Object.fromJson" | "Object.fromRdf" | "Object.hash" | "Object.JSON" | "Object.JSON.type" | "Object.JSON.parse" | "Object.JSON.schema" | "Object.JSON.uiSchema" | "Object.RDF" | "Object.schema" | "Object.SPARQL" | "Object.toJson" | "Object.toRdf" | "Object.toString" | "Object.type" | "ObjectSet" | "RDF" | "RdfjsDatasetObjectSet" | "SPARQL" | "SparqlObjectSet">;
-        const default_: Configuration;
+        const default_: Omit<Configuration, "finalized">;
+        function finalize(ast: ast.Ast, partialConfiguration?: Partial<Configuration>): Configuration;
     }
 }
 //# sourceMappingURL=TsGenerator.d.ts.map

package/dist/generators/ts/TsGenerator.js

@@ -2,39 +2,34 @@ import { Maybe } from "purify-ts";
 import { invariant } from "ts-invariant";
 import * as ast from "../../ast/index.js";
 import { BlankNodeType } from "./BlankNodeType.js";
-import { graphqlSchemaVariableStatement } from "./graphqlSchemaVariableStatement.js";
+import { GraphqlSchema } from "./GraphqlSchema.js";
 import { IdentifierType } from "./IdentifierType.js";
 import { IriType } from "./IriType.js";
 import { NamedObjectUnionType } from "./NamedObjectUnionType.js";
-import { objectSetDeclarations } from "./objectSetDeclarations.js";
+import { ObjectSetType } from "./ObjectSetType.js";
+import { RdfjsDatasetObjectSetType } from "./RdfjsDatasetObjectSetType.js";
 import { Reusables } from "./Reusables.js";
+import { SparqlObjectSetType } from "./SparqlObjectSetType.js";
 import { TypeFactory } from "./TypeFactory.js";
 import { code, joinCode } from "./ts-poet-wrapper.js";
 export class TsGenerator {
-    typeFactory;
     configuration;
     logger;
-    reusables;
     constructor({ configuration, logger, }) {
-        if (!configuration) {
-            configuration = TsGenerator.Configuration.default_;
-        }
-        this.configuration = {
-            ...configuration,
-            features: TsGenerator.Configuration.inferFeatures(configuration.features),
-        };
+        this.configuration = configuration;
         this.logger = logger;
-        this.reusables = new Reusables({
-            configuration: this.configuration,
-            logger,
-        });
-        this.typeFactory = new TypeFactory({
-            configuration: this.configuration,
-            logger,
-            reusables: this.reusables,
-        });
     }
     generate(ast_) {
+        const configuration = TsGenerator.Configuration.finalize(ast_, this.configuration);
+        const reusables = new Reusables({
+            configuration,
+            logger: this.logger,
+        });
+        const typeFactory = new TypeFactory({
+            configuration,
+            logger: this.logger,
+            reusables,
+        });
         let declarations = [];
         for (const namedObjectType of ast_.namedObjectTypes) {
             for (const tsImport of namedObjectType.tsImports) {
@@ -45,12 +40,12 @@ export class TsGenerator {
             if (astNamedUnionType.isObjectUnionType()) {
                 continue;
             }
-            declarations = declarations.concat(this.typeFactory.createType(astNamedUnionType).declaration.toList());
+            declarations = declarations.concat(typeFactory.createType(astNamedUnionType).declaration.toList());
         }
-        const namedObjectTypesToposorted = ast.ObjectType.toposort(ast_.namedObjectTypes).map((astObjectType) => this.typeFactory.createNamedObjectType(astObjectType));
+        const namedObjectTypesToposorted = ast.ObjectType.toposort(ast_.namedObjectTypes).map((astObjectType) => typeFactory.createNamedObjectType(astObjectType));
         const namedObjectUnionTypesToposorted = ast_.namedUnionTypes
             .filter((_) => _.isObjectUnionType())
-            .map((astObjectUnionType) => this.typeFactory.createNamedObjectUnionType(astObjectUnionType));
+            .map((astObjectUnionType) => typeFactory.createNamedObjectUnionType(astObjectUnionType));
         for (const namedObjectType of namedObjectTypesToposorted) {
             declarations = declarations.concat(namedObjectType.declaration.toList());
         }
@@ -63,31 +58,64 @@ export class TsGenerator {
             case 0:
                 break;
             case 1:
-                declarations.push(code `type ${this.configuration.syntheticNamePrefix}Object = ${namedObjectTypesNameSorted[0].name};`);
+                declarations.push(code `type ${configuration.syntheticNamePrefix}Object = ${namedObjectTypesNameSorted[0].name};`);
                 break;
             default: {
-                const uberObjectUnionType = this.synthesizeUberObjectUnionType(namedObjectTypesToposorted.toReversed());
+                const uberObjectUnionType = this.synthesizeUberObjectUnionType({
+                    configuration,
+                    namedObjectTypes: namedObjectTypesToposorted.toReversed(), // Reverse topological order so children ane before parents
+                    reusables,
+                });
                 declarations = declarations.concat(uberObjectUnionType.declaration.toList());
                 namedObjectUnionTypesNameSorted.push(uberObjectUnionType);
             }
         }
-        declarations.push(...objectSetDeclarations.call(this, {
+        declarations.push(...this.objectSetTypeDeclarations({
+            configuration,
             namedObjectTypes: namedObjectTypesNameSorted,
             namedObjectUnionTypes: namedObjectUnionTypesNameSorted,
+            reusables,
         }));
-        declarations.push(...graphqlSchemaVariableStatement
-            .call(this, {
-            namedObjectTypes: namedObjectTypesNameSorted,
-            namedObjectUnionTypes: namedObjectUnionTypesNameSorted,
-        })
-            .toList());
-        declarations.splice(0, 0, joinCode(this.reusables.snippets.ifUsed, { on: "\n\n" }));
+        if (configuration.features.has("GraphQL")) {
+            const graphqlNamedObjectTypes = namedObjectTypesNameSorted.filter((namedObjectType) => !namedObjectType.synthetic);
+            const graphqlNamedObjectUnionTypes = namedObjectUnionTypesNameSorted.filter((namedObjectUnionType) => !namedObjectUnionType.synthetic);
+            if (graphqlNamedObjectTypes.length > 0) {
+                declarations.push(new GraphqlSchema({
+                    configuration,
+                    logger: this.logger,
+                    namedObjectTypes: graphqlNamedObjectTypes,
+                    namedObjectUnionTypes: graphqlNamedObjectUnionTypes,
+                    reusables,
+                }).declaration);
+            }
+        }
+        declarations.splice(0, 0, joinCode(reusables.snippets.ifUsed, { on: "\n\n" }));
         return joinCode(declarations).toString({});
     }
+    objectSetTypeDeclarations({ configuration, namedObjectTypes, namedObjectUnionTypes, reusables, }) {
+        const constructorParameters = {
+            configuration,
+            logger: this.logger,
+            namedObjectTypes: namedObjectTypes.filter((namedObjectType) => !namedObjectType.extern && !namedObjectType.synthetic),
+            namedObjectUnionTypes,
+            reusables,
+        };
+        const declarations = [];
+        if (configuration.features.has("ObjectSet")) {
+            declarations.push(new ObjectSetType(constructorParameters).declaration);
+        }
+        if (configuration.features.has("RdfjsDatasetObjectSet")) {
+            declarations.push(new RdfjsDatasetObjectSetType(constructorParameters).declaration);
+        }
+        if (configuration.features.has("SparqlObjectSet")) {
+            declarations.push(new SparqlObjectSetType(constructorParameters).declaration);
+        }
+        return declarations;
+    }
     /**
      * Synthesize the $Object union.
      */
-    synthesizeUberObjectUnionType(namedObjectTypes) {
+    synthesizeUberObjectUnionType({ configuration, namedObjectTypes, reusables, }) {
         const filteredNamedObjectTypes = namedObjectTypes.filter((namedObjectType) => !namedObjectType.extern);
         invariant(filteredNamedObjectTypes.length > 0);
         const nodeKinds = filteredNamedObjectTypes.reduce((nodeKinds, namedObjectType) => {
@@ -100,10 +128,10 @@ export class TsGenerator {
         if (nodeKinds.size === 2) {
             identifierType = new IdentifierType({
                 comment: Maybe.empty(),
-                configuration: this.configuration,
+                configuration,
                 label: Maybe.empty(),
                 logger: this.logger,
-                reusables: this.reusables,
+                reusables,
             });
         }
         else {
@@ -111,28 +139,28 @@ export class TsGenerator {
                 case "BlankNode":
                     identifierType = new BlankNodeType({
                         comment: Maybe.empty(),
-                        configuration: this.configuration,
+                        configuration,
                         label: Maybe.empty(),
                         logger: this.logger,
-                        reusables: this.reusables,
+                        reusables,
                     });
                     break;
                 case "IRI":
                     identifierType = new IriType({
                         comment: Maybe.empty(),
-                        configuration: this.configuration,
+                        configuration,
                         hasValues: [],
                         in_: [],
                         label: Maybe.empty(),
                         logger: this.logger,
-                        reusables: this.reusables,
+                        reusables,
                     });
                     break;
             }
         }
         return new NamedObjectUnionType({
             comment: Maybe.empty(),
-            configuration: this.configuration,
+            configuration,
             identifierType,
             label: Maybe.empty(),
             logger: this.logger,
@@ -140,9 +168,9 @@ export class TsGenerator {
                 discriminantValue: Maybe.empty(),
                 type: namedObjectType,
             })),
-            name: `${this.configuration.syntheticNamePrefix}Object`,
+            name: `${configuration.syntheticNamePrefix}Object`,
             recursive: false,
-            reusables: this.reusables,
+            reusables,
             synthetic: true,
         });
     }
@@ -150,25 +178,25 @@ export class TsGenerator {
 (function (TsGenerator) {
     let Configuration;
     (function (Configuration) {
-        const featureDependencies = {
+        Configuration.default_ = {
+            features: new Set([
+                "Object.create",
+                "Object.equals",
+                "Object.hash",
+                "JSON",
+                "RDF",
+            ]),
+            syntheticNamePrefix: "$",
+        };
+        const featureDependenciesStatic = {
             GraphQL: ["ObjectSet"],
             // Alias for other features, not dependencies per se
             JSON: ["Object.JSON"],
             "Object.create": ["Object.schema", "Object.toString", "Object.type"],
             "Object.equals": ["Object.type"],
             "Object.filter": ["Object.type"],
-            "Object.fromJson": [
-                "Object.create",
-                "Object.JSON.type",
-                "Object.type",
-                "ObjectSet",
-            ],
-            "Object.fromRdf": [
-                "Object.create",
-                "Object.schema",
-                "ObjectSet",
-                "RdfjsDatasetObjectSet",
-            ],
+            "Object.fromJson": ["Object.create", "Object.JSON.type", "Object.type"],
+            "Object.fromRdf": ["Object.create", "Object.schema"],
             "Object.hash": [],
             // Alias for other features, not dependencies per se
             "Object.JSON": [
@@ -198,31 +226,34 @@ export class TsGenerator {
             SPARQL: ["Object.SPARQL", "SparqlObjectSet"],
             SparqlObjectSet: ["Object.SPARQL", "ObjectSet"],
         };
-        function inferFeatures(features) {
-            const inferredFeatures = new Set(features);
-            const queue = [...features];
-            while (queue.length > 0) {
-                const feature = queue.shift();
-                for (const featureDependency of featureDependencies[feature]) {
-                    if (!inferredFeatures.has(featureDependency)) {
-                        inferredFeatures.add(featureDependency);
-                        queue.push(featureDependency);
+        function finalize(ast, partialConfiguration) {
+            const requestedFeatures = partialConfiguration?.features ?? Configuration.default_.features;
+            const featureDependencies = Object.fromEntries(Object.entries(featureDependenciesStatic).map(([k, v]) => [k, [...v]]));
+            if (ast.lazyTypesCount > 0) {
+                featureDependencies["Object.fromJson"].push("ObjectSet");
+                featureDependencies["Object.fromRdf"].push("ObjectSet", "RdfjsDatasetObjectSet");
+            }
+            const inferredFeatures = new Set(requestedFeatures);
+            {
+                const inferredFeaturesQueue = [...requestedFeatures];
+                while (inferredFeaturesQueue.length > 0) {
+                    const feature = inferredFeaturesQueue.shift();
+                    for (const featureDependency of featureDependencies[feature]) {
+                        if (!inferredFeatures.has(featureDependency)) {
+                            inferredFeatures.add(featureDependency);
+                            inferredFeaturesQueue.push(featureDependency);
+                        }
                     }
                 }
             }
-            return inferredFeatures;
+            return {
+                features: inferredFeatures,
+                finalized: true,
+                syntheticNamePrefix: partialConfiguration?.syntheticNamePrefix ??
+                    Configuration.default_.syntheticNamePrefix,
+            };
         }
-        Configuration.inferFeatures = inferFeatures;
-        Configuration.default_ = {
-            features: inferFeatures(new Set([
-                "Object.create",
-                "Object.equals",
-                "Object.hash",
-                "JSON",
-                "RDF",
-            ])),
-            syntheticNamePrefix: "$",
-        };
+        Configuration.finalize = finalize;
     })(Configuration = TsGenerator.Configuration || (TsGenerator.Configuration = {}));
 })(TsGenerator || (TsGenerator = {}));
 //# sourceMappingURL=TsGenerator.js.map

package/dist/generators/ts/ZodGenerator.d.ts

@@ -2,8 +2,7 @@ import type { Logger } from "ts-log";
 import * as ast from "../../ast/index.js";
 import type { Generator } from "../Generator.js";
 export declare class ZodGenerator implements Generator {
-    private readonly reusables;
-    private readonly typeFactory;
+    private readonly logger;
     constructor({ logger }: {
         logger: Logger;
     });

package/dist/generators/ts/ZodGenerator.js

@@ -7,20 +7,20 @@ import { TsGenerator } from "./TsGenerator.js";
 import { TypeFactory } from "./TypeFactory.js";
 import { code, joinCode } from "./ts-poet-wrapper.js";
 export class ZodGenerator {
-    reusables;
-    typeFactory;
+    logger;
     constructor({ logger }) {
-        const configuration = TsGenerator.Configuration.default_;
-        this.reusables = new Reusables({ configuration, logger });
-        this.typeFactory = new TypeFactory({
-            configuration,
-            logger,
-            reusables: this.reusables,
-        });
+        this.logger = logger;
     }
     generate(ast_) {
+        const configuration = TsGenerator.Configuration.finalize(ast_, TsGenerator.Configuration.default_);
+        const reusables = new Reusables({ configuration, logger: this.logger });
+        const typeFactory = new TypeFactory({
+            configuration,
+            logger: this.logger,
+            reusables,
+        });
         const declarations = [];
-        for (const namedObjectType of ast.ObjectType.toposort(ast_.namedObjectTypes).map((astObjectType) => this.typeFactory.createNamedObjectType(astObjectType))) {
+        for (const namedObjectType of ast.ObjectType.toposort(ast_.namedObjectTypes).map((astObjectType) => typeFactory.createNamedObjectType(astObjectType))) {
             declarations.push(code `\
 export namespace ${namedObjectType.name} {
   ${joinCode(NamedObjectType_jsonTypeAliasDeclaration.call(namedObjectType).toList())}
@@ -30,7 +30,7 @@ export namespace ${namedObjectType.name} {
   }
 }`);
         }
-        for (const astNamedUnionType of ast_.namedUnionTypes.map((astNamedUnionType) => this.typeFactory.createUnionType(astNamedUnionType))) {
+        for (const astNamedUnionType of ast_.namedUnionTypes.map((astNamedUnionType) => typeFactory.createUnionType(astNamedUnionType))) {
             invariant(astNamedUnionType.kind !== "AnonymousUnionType");
             declarations.push(code `\
 export namespace ${astNamedUnionType.name} {
@@ -40,7 +40,7 @@ export namespace ${astNamedUnionType.name} {
   }
 }`);
         }
-        declarations.splice(0, 0, joinCode(this.reusables.snippets.ifUsed, { on: "\n\n" }));
+        declarations.splice(0, 0, joinCode(reusables.snippets.ifUsed, { on: "\n\n" }));
         return joinCode(declarations, { on: "\n\n" }).toString({});
     }
 }

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

@@ -37,19 +37,25 @@ export function NamedObjectType_createFunctionDeclaration() {
         expression: code `${this.reusables.snippets.sequenceRecord}({ ${joinCode(propertyInitializers, { on: "," })} })`,
         variable: "properties",
     });
-    const syntheticNamePrefix = this.configuration.syntheticNamePrefix;
+    let returnExpression = code `{ ${chains
+        .map((chain) => `...${chain.variable}`)
+        .join(", ")}, ${this._discriminantProperty.name}: ${literalOf(this.discriminantValue)} as const }`;
+    const monkeyPatchMethods = [];
+    if (this.configuration.features.has("Object.toJson")) {
+        monkeyPatchMethods.push("toJson");
+    }
+    if (this.configuration.features.has("Object.toString")) {
+        monkeyPatchMethods.push(`${this.configuration.syntheticNamePrefix}toString`);
+    }
+    if (monkeyPatchMethods.length > 0) {
+        returnExpression = code `${this.reusables.snippets.monkeyPatchObject}(${returnExpression}, { ${monkeyPatchMethods.join(", ")} })`;
+    }
+    returnExpression = chains
+        .toReversed()
+        .reduce((acc, { expression, variable }, chainI) => code `(${expression}).${chainI === 0 ? "map" : "chain"}(${variable} => ${acc})`, returnExpression);
     return Maybe.of(code `\
 export function create(${parametersSignature}): ${this.reusables.imports.Either}<Error, ${this.name}> {
-  return ${chains.toReversed().reduce((acc, { expression, variable }, chainI) => code `(${expression}).${chainI === 0 ? "map" : "chain"}(${variable} => ${acc})`, code `\
-{
-  const finalObject = { ${chains
-        .map((chain) => `...${chain.variable}`)
-        .join(", ")}, ${this._discriminantProperty.name}: ${literalOf(this.discriminantValue)} as const };
-  if (!globalThis.Object.prototype.hasOwnProperty.call(finalObject, "toString")) {
-    (finalObject as any).toString = ${syntheticNamePrefix}toString;
-  }
-  return finalObject;
-}`)};
+  return ${returnExpression};
 }
   
 export function createUnsafe(${parametersSignature}): ${this.name} {

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

@@ -19,6 +19,7 @@ export function NamedObjectType_toJsonFunctionDeclaration() {
         })
             .toList()));
     }
+    const returnType = this.jsonType().name;
     // 20241220: don't add @type until we're doing JSON-LD
     // switch (this.toRdfTypes.length) {
     //   case 0:
@@ -33,7 +34,7 @@ export function NamedObjectType_toJsonFunctionDeclaration() {
     //     break;
     // }
     return Maybe.of(code `\
-export function toJson(${this.thisVariable}: ${this.name}): ${this.jsonType().name} {
+export function toJson(${this.thisVariable}: ${this.name}): ${returnType} {
   return JSON.parse(JSON.stringify({ ${joinCode(jsonObjectMembers, { on: "," })} } satisfies ${this.jsonType().name}));
 }`);
 }

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

@@ -28,10 +28,8 @@ export function _propertiesToStrings(${this.thisVariable}: ${this.name}): Record
   return ${propertiesToStringsReturnExpression};
 }`,
         code `\
-export function ${syntheticNamePrefix}toString(this: ${this.name}): string;
-export function ${syntheticNamePrefix}toString(${this.thisVariable}: ${this.name}): string;
-export function ${syntheticNamePrefix}toString(this: ${this.name} | undefined, ${this.thisVariable}?: ${this.name}): string {
-  return ${toStringReturnExpression(code `_propertiesToStrings((${this.thisVariable} ?? this)!)`)};
+export function ${syntheticNamePrefix}toString(${this.thisVariable}: ${this.name}): string {
+  return ${toStringReturnExpression(code `_propertiesToStrings(${this.thisVariable})`)};
 }`,
     ];
 }

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

@@ -1,12 +1,12 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-export const snippets_FromRdfResourceFunction = ({ imports, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}FromRdfResourceFunction`, code `\
+export const snippets_FromRdfResourceFunction = ({ configuration, imports, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}FromRdfResourceFunction`, code `\
 export type ${syntheticNamePrefix}FromRdfResourceFunction<T> = (
   resource: ${imports.Resource},
   options?: {
     context?: unknown;
     graph?: Exclude<${imports.Quad_Graph}, ${imports.Variable}>;
     ignoreRdfType?: boolean;
-    objectSet?: ${syntheticNamePrefix}ObjectSet;
+    ${configuration.features.has("ObjectSet") ? code `objectSet?: ${syntheticNamePrefix}ObjectSet;` : ""}
     preferredLanguages?: readonly string[];
   }
 ) => ${imports.Either}<Error, T>`);

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

@@ -1,12 +1,12 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-export const snippets_FromRdfResourceValuesFunction = ({ imports, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}FromRdfResourceValuesFunction`, code `\
+export const snippets_FromRdfResourceValuesFunction = ({ configuration, imports, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}FromRdfResourceValuesFunction`, code `\
 export type ${syntheticNamePrefix}FromRdfResourceValuesFunction<T> = (
   resourceValues: ${imports.Either}<Error, ${imports.Resource}.Values>,
   options: {
     context?: unknown;
     graph?: Exclude<${imports.Quad_Graph}, ${imports.Variable}>;
     ignoreRdfType?: boolean;
-    objectSet?: ${syntheticNamePrefix}ObjectSet;
+    ${configuration.features.has("ObjectSet") ? code `objectSet?: ${syntheticNamePrefix}ObjectSet;` : ""}
     preferredLanguages?: readonly string[];
     propertyPath: ${syntheticNamePrefix}PropertyPath;
     resource: ${imports.Resource};

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

@@ -1,12 +1,12 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-export const snippets__FromRdfResourceFunction = ({ imports, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}_FromRdfResourceFunction`, code `\
+export const snippets__FromRdfResourceFunction = ({ configuration, imports, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}_FromRdfResourceFunction`, code `\
 type ${syntheticNamePrefix}_FromRdfResourceFunction<T> = (
   resource: ${imports.Resource},
   options: {
     context: undefined | unknown;
     graph: Exclude<${imports.Quad_Graph}, ${imports.Variable}> | undefined;
     ignoreRdfType: boolean;
-    objectSet: ${syntheticNamePrefix}ObjectSet;
+    ${configuration.features.has("ObjectSet") ? code `objectSet: ${syntheticNamePrefix}ObjectSet;` : ""}
     preferredLanguages: readonly string[] | undefined;
   }
 ) => ${imports.Either}<Error, T>;`);

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

@@ -0,0 +1,3 @@
+import type { SnippetFactory } from "../SnippetFactory.js";
+export declare const snippets_monkeyPatchObject: SnippetFactory;
+//# sourceMappingURL=snippets_monkeyPatchObject.d.ts.map

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

@@ -0,0 +1,16 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_monkeyPatchObject = ({ syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}monkeyPatchObject`, code `\
+function ${syntheticNamePrefix}monkeyPatchObject<T extends object>(obj: T, methods: { toJson?: (obj: T) => object, ${syntheticNamePrefix}toString?: (obj: T) => string }): T {
+  if (methods.toJson && (!globalThis.Object.prototype.hasOwnProperty.call(obj, "toJSON") || typeof (obj as any).toJSON === "function")) {
+    const toJsonMethod = methods.toJson;
+    (obj as any).toJSON = function(this: T, _key: string) { return toJsonMethod(this); }
+  }
+
+  if (methods.${syntheticNamePrefix}toString && (!globalThis.Object.prototype.hasOwnProperty.call(obj, "toString") || typeof (obj as any).toJSON === "function")) {
+    const toStringMethod = methods.${syntheticNamePrefix}toString;
+    (obj as any).toString = function(this: T) { return toStringMethod(this); }
+  }
+
+  return obj;
+}`);
+//# sourceMappingURL=snippets_monkeyPatchObject.js.map