@shaclmate/compiler 4.0.35 → 4.0.37

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,
         });
     }
@@ -151,20 +179,81 @@ export class TsGenerator {
     let Configuration;
     (function (Configuration) {
         Configuration.default_ = {
-            features: new Set(["create", "equals", "hash", "json", "rdf"]),
+            features: new Set([
+                "Object.create",
+                "Object.equals",
+                "Object.hash",
+                "JSON",
+                "RDF",
+            ]),
             syntheticNamePrefix: "$",
         };
-        function inferFeatures(features) {
-            const inferredFeatures = new Set(features);
-            if (inferredFeatures.has("graphql") || inferredFeatures.has("sparql")) {
-                inferredFeatures.add("rdf");
+        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"],
+            "Object.fromRdf": ["Object.create", "Object.schema"],
+            "Object.hash": [],
+            // Alias for other features, not dependencies per se
+            "Object.JSON": [
+                "Object.fromJson",
+                "Object.JSON.parse",
+                "Object.JSON.schema",
+                "Object.JSON.type",
+                "Object.JSON.uiSchema",
+                "Object.toJson",
+            ],
+            "Object.JSON.parse": ["Object.JSON.schema", "Object.JSON.type"],
+            "Object.JSON.type": [],
+            "Object.JSON.schema": ["Object.JSON.type"],
+            "Object.JSON.uiSchema": [],
+            // Alias for other features, not dependencies per se
+            "Object.RDF": ["Object.fromRdf", "Object.toRdf"],
+            "Object.schema": [],
+            "Object.toJson": ["Object.JSON.type", "Object.type"],
+            "Object.toRdf": ["Object.schema", "Object.type"],
+            "Object.toString": ["Object.type"],
+            "Object.SPARQL": ["Object.schema"],
+            "Object.type": [], // Implies Object.Identifier
+            ObjectSet: ["Object.filter"],
+            // Alias for other features, not dependencies per se
+            RDF: ["Object.RDF", "RdfjsDatasetObjectSet"],
+            RdfjsDatasetObjectSet: ["Object.fromRdf", "ObjectSet"],
+            SPARQL: ["Object.SPARQL", "SparqlObjectSet"],
+            SparqlObjectSet: ["Object.SPARQL", "ObjectSet"],
+        };
+        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");
             }
-            if (inferredFeatures.has("json") || inferredFeatures.has("rdf")) {
-                inferredFeatures.add("create");
+            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.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

@@ -2,7 +2,7 @@ import { Maybe } from "purify-ts";
 import { invariant } from "ts-invariant";
 import { code, joinCode, literalOf } from "../ts-poet-wrapper.js";
 export function NamedObjectType_createFunctionDeclaration() {
-    if (!this.configuration.features.has("create")) {
+    if (!this.configuration.features.has("Object.create")) {
         return Maybe.empty();
     }
     const parametersPropertySignatures = this.properties.flatMap((property) => property.constructorParameter.toList());
@@ -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_equalsFunctionDeclaration.js

@@ -1,7 +1,7 @@
 import { Maybe } from "purify-ts";
 import { code, joinCode } from "../ts-poet-wrapper.js";
 export function NamedObjectType_equalsFunctionDeclaration() {
-    if (!this.configuration.features.has("equals")) {
+    if (!this.configuration.features.has("Object.equals")) {
         return Maybe.empty();
     }
     const chain = [];

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

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

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

@@ -1,5 +1,9 @@
+import { Maybe } from "purify-ts";
 import { code, joinCode } from "../ts-poet-wrapper.js";
 export function NamedObjectType_filterFunctionDeclaration() {
+    if (!this.configuration.features.has("Object.filter")) {
+        return Maybe.empty();
+    }
     const statements = [];
     for (const parentObjectType of this.parentObjectTypes) {
         statements.push(code `if (!${parentObjectType.filterFunction}(filter, value)) { return false; }`);
@@ -12,9 +16,9 @@ export function NamedObjectType_filterFunctionDeclaration() {
         }
     }
     statements.push(code `return true;`);
-    return code `\
+    return Maybe.of(code `\
 export function filter(filter: ${this.filterType}, value: ${this.name}): boolean {
   ${joinCode(statements)}
-}`;
+}`);
 }
 //# sourceMappingURL=NamedObjectType_filterFunctionDeclaration.js.map

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

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

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

@@ -1,5 +1,9 @@
+import { Maybe } from "purify-ts";
 import { code, joinCode } from "../ts-poet-wrapper.js";
 export function NamedObjectType_filterTypeDeclaration() {
+    if (!this.configuration.features.has("Object.filter")) {
+        return Maybe.empty();
+    }
     const members = [];
     if (this.properties.length > 0) {
         const filterProperties = {};
@@ -15,7 +19,7 @@ export function NamedObjectType_filterTypeDeclaration() {
     for (const parentObjectType of this.parentObjectTypes) {
         members.push(code `${parentObjectType.name}.Filter`);
     }
-    return code `\
-export type Filter = ${members.length > 0 ? joinCode(members, { on: " & " }) : "object"};`;
+    return Maybe.of(code `\
+export type Filter = ${members.length > 0 ? joinCode(members, { on: " & " }) : "object"};`);
 }
 //# sourceMappingURL=NamedObjectType_filterTypeDeclaration.js.map

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

@@ -7,7 +7,7 @@ const variables = {
     variablePrefix: code `parameters.variablePrefix`,
 };
 export function NamedObjectType_focusSparqlConstructTriplesFunctionDeclaration() {
-    if (!this.configuration.features.has("sparql")) {
+    if (!this.configuration.features.has("Object.SPARQL")) {
         return Maybe.empty();
     }
     const rdfClassVariable = code `${this.reusables.imports.dataFactory}.variable!(\`\${${variables.variablePrefix}}RdfClass\`)`;

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

@@ -8,7 +8,7 @@ const variables = {
     variablePrefix: code `parameters.variablePrefix`,
 };
 export function NamedObjectType_focusSparqlWherePatternsFunctionDeclaration() {
-    if (!this.configuration.features.has("sparql")) {
+    if (!this.configuration.features.has("Object.SPARQL")) {
         return Maybe.empty();
     }
     const rdfClassVariable = code `${this.reusables.imports.dataFactory}.variable!(\`\${${variables.variablePrefix}}RdfClass\`)`;

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

@@ -1,7 +1,7 @@
 import { Maybe } from "purify-ts";
 import { code, joinCode } from "../ts-poet-wrapper.js";
 export function NamedObjectType_fromJsonFunctionDeclaration() {
-    if (!this.configuration.features.has("json")) {
+    if (!this.configuration.features.has("Object.fromJson")) {
         return Maybe.empty();
     }
     const variables = {

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

@@ -2,7 +2,7 @@ import { rdf } from "@tpluscode/rdf-ns-builders";
 import { Maybe } from "purify-ts";
 import { code, joinCode } from "../ts-poet-wrapper.js";
 export function NamedObjectType_fromRdfResourceFunctionDeclaration() {
-    if (!this.configuration.features.has("rdf")) {
+    if (!this.configuration.features.has("Object.fromRdf")) {
         return Maybe.empty();
     }
     const syntheticNamePrefix = this.configuration.syntheticNamePrefix;

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

@@ -1,7 +1,7 @@
 import { Maybe } from "purify-ts";
 import { code } from "../ts-poet-wrapper.js";
 export function NamedObjectType_fromRdfResourceValuesFunctionDeclaration() {
-    if (!this.configuration.features.has("rdf")) {
+    if (!this.configuration.features.has("Object.fromRdf")) {
         return Maybe.empty();
     }
     return Maybe.of(code `\

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

@@ -1,7 +1,7 @@
 import { Maybe } from "purify-ts";
 import { code } from "../ts-poet-wrapper.js";
 export function NamedObjectType_fromRdfTypeVariableStatement() {
-    if (!this.configuration.features.has("rdf")) {
+    if (!this.configuration.features.has("Object.fromRdf")) {
         return Maybe.empty();
     }
     return this.fromRdfType.map((fromRdfType) => code `\

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

@@ -1,7 +1,7 @@
 import { Maybe } from "purify-ts";
 import { code } from "../ts-poet-wrapper.js";
 export function NamedObjectType_graphqlTypeVariableStatement() {
-    if (!this.configuration.features.has("graphql")) {
+    if (!this.configuration.features.has("GraphQL")) {
         return Maybe.empty();
     }
     if (this.synthetic) {

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

@@ -1,7 +1,7 @@
 import { code, joinCode } from "../ts-poet-wrapper.js";
 const hasherVariable = code `hasher`;
 export function NamedObjectType_hashFunctionDeclarations() {
-    if (!this.configuration.features.has("hash")) {
+    if (!this.configuration.features.has("Object.hash")) {
         return [];
     }
     const hashOwnShaclPropertiesStatements = this.properties.flatMap((property) => property.kind === "ShaclProperty"

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

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

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

@@ -1,6 +1,10 @@
+import { Maybe } from "purify-ts";
 import { code } from "../ts-poet-wrapper.js";
 export function NamedObjectType_isTypeFunctionDeclaration() {
-    return code `\
+    if (!this.configuration.features.has("Object.type")) {
+        return Maybe.empty();
+    }
+    return Maybe.of(code `\
 export function is${this.name}(object: ${this.configuration.syntheticNamePrefix}Object): object is ${this.name} {
   switch (object.${this._discriminantProperty.name}) {
     ${this._discriminantProperty.type.descendantValues
@@ -8,6 +12,6 @@ export function is${this.name}(object: ${this.configuration.syntheticNamePrefix}
         .map((value) => `case "${value}":`)
         .join("\n")} return true; default: return false;
   }
-}`;
+}`);
 }
 //# sourceMappingURL=NamedObjectType_isTypeFunctionDeclaration.js.map

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

@@ -1,7 +1,7 @@
 import { Maybe } from "purify-ts";
 import { code } from "../ts-poet-wrapper.js";
 export function NamedObjectType_jsonParseFunctionDeclaration() {
-    if (!this.configuration.features.has("json")) {
+    if (!this.configuration.features.has("Object.JSON.parse")) {
         return Maybe.empty();
     }
     return Maybe.of(code `\

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

@@ -1,7 +1,7 @@
 import { Maybe } from "purify-ts";
 import { code, joinCode } from "../ts-poet-wrapper.js";
 export function NamedObjectType_jsonSchemaFunctionDeclaration() {
-    if (!this.configuration.features.has("json")) {
+    if (!this.configuration.features.has("Object.JSON.schema")) {
         return Maybe.empty();
     }
     let properties = [];

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

@@ -1,7 +1,7 @@
 import { Maybe } from "purify-ts";
 import { code, joinCode } from "../ts-poet-wrapper.js";
 export function NamedObjectType_jsonTypeAliasDeclaration() {
-    if (!this.configuration.features.has("json")) {
+    if (!this.configuration.features.has("Object.JSON.type")) {
         return Maybe.empty();
     }
     const members = [];

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

@@ -1,7 +1,7 @@
 import { Maybe } from "purify-ts";
 import { code, joinCode } from "../ts-poet-wrapper.js";
 export function NamedObjectType_jsonUiSchemaFunctionDeclaration() {
-    if (!this.configuration.features.has("json")) {
+    if (!this.configuration.features.has("Object.JSON.uiSchema")) {
         return Maybe.empty();
     }
     const variables = { scopePrefix: code `scopePrefix` };

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

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

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

@@ -1,8 +1,12 @@
+import { Maybe } from "purify-ts";
 import { code, joinCode } from "../ts-poet-wrapper.js";
 export function NamedObjectType_schemaVariableStatement() {
-    return code `\
+    if (!this.configuration.features.has("Object.schema")) {
+        return Maybe.empty();
+    }
+    return Maybe.of(code `\
 export const schema = { properties: { ${joinCode(this.parentObjectTypes
         .map((parentObjectType) => code `...${parentObjectType.name}.schema.properties`)
-        .concat(this.properties.map((property) => code `${property.name}: ${property.schema}`)), { on: ", " })} } } as const;`;
+        .concat(this.properties.map((property) => code `${property.name}: ${property.schema}`)), { on: ", " })} } } as const;`);
 }
 //# sourceMappingURL=NamedObjectType_schemaVariableStatement.js.map