@shaclmate/compiler 4.0.35 → 4.0.36

package/dist/generators/ts/AbstractNamedUnionType.js

@@ -16,9 +16,10 @@ export class AbstractNamedUnionType extends AbstractUnionType {
         this._name = name;
     }
     get declaration() {
-        const declarations = [
-            code `export type ${def(this._name)} = ${this.inlineName};`,
-        ];
+        const declarations = [];
+        if (this.configuration.features.has("Object.type")) {
+            declarations.push(code `export type ${def(this._name)} = ${this.inlineName};`);
+        }
         const staticModuleDeclarations = Object.entries(this.staticModuleDeclarations);
         if (staticModuleDeclarations.length > 0) {
             declarations.push(code `\
@@ -68,22 +69,26 @@ ${joinCode(staticModuleDeclarations
     }
     get staticModuleDeclarations() {
         const staticModuleDeclarations = {};
-        if (this.configuration.features.has("equals")) {
+        if (this.configuration.features.has("Object.equals")) {
             staticModuleDeclarations[`equals`] =
                 code `export const equals = ${this.inlineEqualsFunction};`;
         }
-        staticModuleDeclarations[`Filter`] =
-            code `export type Filter = ${this.inlineFilterType};`;
-        staticModuleDeclarations[`filter`] =
-            code `export const filter = ${this.inlineFilterFunction};`;
-        if (this.configuration.features.has("hash")) {
+        if (this.configuration.features.has("Object.filter")) {
+            staticModuleDeclarations[`Filter`] =
+                code `export type Filter = ${this.inlineFilterType};`;
+            staticModuleDeclarations[`filter`] =
+                code `export const filter = ${this.inlineFilterFunction};`;
+        }
+        if (this.configuration.features.has("Object.hash")) {
             staticModuleDeclarations[`hash`] =
                 code `export const hash = ${this.inlineHashFunction};`;
         }
-        if (this.configuration.features.has("json")) {
-            staticModuleDeclarations[`Json`] = code `\
-${this.jsonTypeAliasDeclaration}
-
+        if (this.configuration.features.has("Object.JSON.type")) {
+            staticModuleDeclarations[`Json.type`] =
+                code `${this.jsonTypeAliasDeclaration}`;
+        }
+        if (this.configuration.features.has("Object.JSON.schema")) {
+            staticModuleDeclarations[`Json.namespace`] = code `\
 export namespace Json {
   ${this.jsonSchemaFunctionDeclaration}
 
@@ -93,26 +98,34 @@ export namespace Json {
     return ${this.reusables.imports.Right}(jsonSafeParseResult.data);
   }
 }`;
+        }
+        if (this.configuration.features.has("Object.fromJson")) {
             staticModuleDeclarations[`fromJson`] =
                 code `export const fromJson = ${this.inlineFromJsonFunction};`;
-            staticModuleDeclarations[`toJson`] =
-                code `export const toJson = ${this.inlineToJsonFunction};`;
         }
-        if (this.configuration.features.has("rdf")) {
+        if (this.configuration.features.has("Object.fromRdf")) {
             staticModuleDeclarations[`fromRdfResourceValues`] =
                 code `export const fromRdfResourceValues: ${this.reusables.snippets.FromRdfResourceValuesFunction}<${this.name}> = ${this.inlineFromRdfResourceValuesFunction};`;
+        }
+        if (this.configuration.features.has("Object.toJson")) {
+            staticModuleDeclarations[`toJson`] =
+                code `export const toJson = ${this.inlineToJsonFunction};`;
+        }
+        if (this.configuration.features.has("Object.toRdf")) {
             staticModuleDeclarations[`toRdfResourceValues`] =
                 code `export const toRdfResourceValues = ${this.inlineToRdfResourceValuesFunction};`;
         }
-        if (this.configuration.features.has("sparql")) {
+        if (this.configuration.features.has("Object.SPARQL")) {
             staticModuleDeclarations[`valueSparqlConstructTriples`] =
                 code `export const valueSparqlConstructTriples: ${this.reusables.snippets.ValueSparqlConstructTriplesFunction}<${this.filterType}, ${this.schemaType}> = ${this.inlineValueSparqlConstructTriplesFunction};`;
             staticModuleDeclarations[`valueSparqlWherePatterns`] =
                 code `export const valueSparqlWherePatterns: ${this.reusables.snippets.ValueSparqlWherePatternsFunction}<${this.filterType}, ${this.schemaType}> = ${this.inlineValueSparqlWherePatternsFunction};`;
         }
-        const syntheticNamePrefix = this.configuration.syntheticNamePrefix;
-        staticModuleDeclarations[`${syntheticNamePrefix}toString`] =
-            code `export const ${syntheticNamePrefix}toString = ${this.inlineToStringFunction};`;
+        if (this.configuration.features.has("Object.toString")) {
+            const syntheticNamePrefix = this.configuration.syntheticNamePrefix;
+            staticModuleDeclarations[`${syntheticNamePrefix}toString`] =
+                code `export const ${syntheticNamePrefix}toString = ${this.inlineToStringFunction};`;
+        }
         return staticModuleDeclarations;
     }
     fromJsonExpression({ variables, }) {

package/dist/generators/ts/NamedObjectType.js

@@ -84,7 +84,9 @@ export class NamedObjectType extends AbstractType {
         const declarations = [];
         if (!this.extern) {
             const staticModuleDeclarations = [];
-            declarations.push(NamedObjectType_interfaceDeclaration.call(this));
+            if (this.configuration.features.has("Object.type")) {
+                declarations.push(NamedObjectType_interfaceDeclaration.call(this));
+            }
             staticModuleDeclarations.push(...NamedObjectType_createFunctionDeclaration.call(this).toList(), ...NamedObjectType_equalsFunctionDeclaration.call(this).toList(), ...NamedObjectType_hashFunctionDeclarations.call(this));
             const jsonModuleDeclarations = [
                 ...NamedObjectType_jsonParseFunctionDeclaration.call(this).toList(),
@@ -95,7 +97,7 @@ export class NamedObjectType extends AbstractType {
                 ? [
                     code `export namespace Json { ${joinCode(jsonModuleDeclarations, { on: "\n\n" })} }`,
                 ]
-                : []), NamedObjectType_filterFunctionDeclaration.call(this), NamedObjectType_filterTypeDeclaration.call(this), ...NamedObjectType_focusSparqlConstructTriplesFunctionDeclaration.call(this).toList(), ...NamedObjectType_focusSparqlWherePatternsFunctionDeclaration.call(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.call({
+                : []), ...NamedObjectType_filterFunctionDeclaration.call(this).toList(), ...NamedObjectType_filterTypeDeclaration.call(this).toList(), ...NamedObjectType_focusSparqlConstructTriplesFunctionDeclaration.call(this).toList(), ...NamedObjectType_focusSparqlWherePatternsFunctionDeclaration.call(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).toList(), ...NamedObjectType_schemaVariableStatement.call(this).toList(), ...NamedObjectType_sparqlConstructQueryFunctionDeclaration.call({
                 configuration: this.configuration,
                 filterType: this.filterType,
                 name: this.name,
@@ -113,6 +115,9 @@ ${joinCode(staticModuleDeclarations, { on: "\n\n" })}
 }`);
             }
         }
+        if (declarations.length === 0) {
+            return Maybe.empty();
+        }
         return Maybe.of(joinCode(declarations, { on: "\n\n" }));
     }
     get descendantFromRdfTypeVariables() {

package/dist/generators/ts/NamedObjectUnionType.js

@@ -73,7 +73,7 @@ export class NamedObjectUnionType extends AbstractNamedUnionType {
         };
     }
     get focusSparqlConstructTriplesFunctionDeclaration() {
-        if (!this.configuration.features.has("sparql")) {
+        if (!this.configuration.features.has("Object.SPARQL")) {
             return {};
         }
         return singleEntryRecord(`focusSparqlConstructTriples`, code `\
@@ -82,7 +82,7 @@ export function focusSparqlConstructTriples({ filter, focusIdentifier, variableP
 }`);
     }
     get focusSparqlWherePatternsFunctionDeclaration() {
-        if (!this.configuration.features.has("sparql")) {
+        if (!this.configuration.features.has("Object.SPARQL")) {
             return {};
         }
         return singleEntryRecord(`focusSparqlWherePatterns`, code `\
@@ -110,7 +110,7 @@ if (focusIdentifier.termType === "Variable") {
 }`);
     }
     get fromRdfResourceFunctionDeclaration() {
-        if (!this.configuration.features.has("rdf")) {
+        if (!this.configuration.features.has("Object.fromRdf")) {
             return {};
         }
         return singleEntryRecord(`fromRdfResource`, code `\
@@ -123,7 +123,7 @@ export const fromRdfResource: ${this.reusables.snippets.FromRdfResourceFunction}
         }, null)};`);
     }
     get graphqlTypeVariableStatement() {
-        if (!this.configuration.features.has("graphql")) {
+        if (!this.configuration.features.has("GraphQL")) {
             return {};
         }
         if (this.synthetic) {
@@ -138,6 +138,9 @@ export const GraphQL = new ${this.reusables.imports.GraphQLUnionType}(${{
         }});`);
     }
     get identifierTypeDeclarations() {
+        if (!this.configuration.features.has("Object.type")) {
+            return {};
+        }
         return singleEntryRecord(`Identifier`, code `\
 export type Identifier = ${this.#identifierType.name};
 export namespace Identifier {
@@ -146,6 +149,9 @@ export namespace Identifier {
 }`);
     }
     get isTypeFunctionDeclaration() {
+        if (!this.configuration.features.has("Object.type")) {
+            return {};
+        }
         if (this._name === `${this.configuration.syntheticNamePrefix}Object`) {
             return {};
         }
@@ -155,6 +161,9 @@ export namespace Identifier {
     }`);
     }
     get schemaVariableStatement() {
+        if (!this.configuration.features.has("Object.schema")) {
+            return {};
+        }
         const commonPropertiesByName = {};
         this.members.forEach((member, memberI) => {
             for (const memberTypeProperty of member.type.properties.concat(member.type.ancestorObjectTypes.flatMap((ancestorObjectType) => ancestorObjectType.properties))) {
@@ -192,7 +201,7 @@ ${{
         }} as const;`);
     }
     get toRdfResourceFunctionDeclaration() {
-        if (!this.configuration.features.has("rdf")) {
+        if (!this.configuration.features.has("Object.toRdf")) {
             return {};
         }
         return singleEntryRecord(`toRdfResource`, code `\

package/dist/generators/ts/TsFeature.d.ts

@@ -1,3 +1,3 @@
 export type TsFeature = (typeof TS_FEATURES)[number];
-export declare const TS_FEATURES: readonly ["create", "equals", "graphql", "hash", "json", "rdf", "sparql"];
+export declare const TS_FEATURES: readonly ["GraphQL", "JSON", "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"];
 //# sourceMappingURL=TsFeature.d.ts.map

package/dist/generators/ts/TsFeature.js

@@ -1,10 +1,28 @@
 export const TS_FEATURES = [
-    "create",
-    "equals",
-    "graphql",
-    "hash",
-    "json",
-    "rdf",
-    "sparql",
+    "GraphQL",
+    "JSON",
+    "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",
 ];
 //# sourceMappingURL=TsFeature.js.map

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

@@ -24,8 +24,8 @@ export declare namespace TsGenerator {
         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;
-        function inferFeatures(features: ReadonlySet<TsFeature>): Set<"equals" | "create" | "graphql" | "hash" | "json" | "rdf" | "sparql">;
     }
 }
 //# sourceMappingURL=TsGenerator.d.ts.map

package/dist/generators/ts/TsGenerator.js

@@ -150,21 +150,79 @@ export class TsGenerator {
 (function (TsGenerator) {
     let Configuration;
     (function (Configuration) {
-        Configuration.default_ = {
-            features: new Set(["create", "equals", "hash", "json", "rdf"]),
-            syntheticNamePrefix: "$",
+        const featureDependencies = {
+            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.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 inferFeatures(features) {
             const inferredFeatures = new Set(features);
-            if (inferredFeatures.has("graphql") || inferredFeatures.has("sparql")) {
-                inferredFeatures.add("rdf");
-            }
-            if (inferredFeatures.has("json") || inferredFeatures.has("rdf")) {
-                inferredFeatures.add("create");
+            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);
+                    }
+                }
             }
             return inferredFeatures;
         }
         Configuration.inferFeatures = inferFeatures;
+        Configuration.default_ = {
+            features: inferFeatures(new Set([
+                "Object.create",
+                "Object.equals",
+                "Object.hash",
+                "JSON",
+                "RDF",
+            ])),
+            syntheticNamePrefix: "$",
+        };
     })(Configuration = TsGenerator.Configuration || (TsGenerator.Configuration = {}));
 })(TsGenerator || (TsGenerator = {}));
 //# sourceMappingURL=TsGenerator.js.map

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());

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

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

@@ -2,7 +2,7 @@ import { camelCase } from "change-case";
 import { Maybe } from "purify-ts";
 import { code } from "../ts-poet-wrapper.js";
 export function NamedObjectType_sparqlConstructQueryFunctionDeclaration() {
-    if (!this.configuration.features.has("sparql")) {
+    if (!this.configuration.features.has("Object.SPARQL")) {
         return Maybe.empty();
     }
     return Maybe.of(code `\

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

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

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

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