@shaclmate/compiler 4.0.34 → 4.0.36

package/dist/generators/ts/TermType.js

@@ -6,11 +6,13 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 };
 import { NodeKind } from "@shaclmate/shacl-ast";
 import { xsd } from "@tpluscode/rdf-ns-builders";
+import { Maybe } from "purify-ts";
 import { invariant } from "ts-invariant";
 import { Memoize } from "typescript-memoize";
 import { AbstractTermType } from "./AbstractTermType.js";
 import { code, joinCode } from "./ts-poet-wrapper.js";
 export class TermType extends AbstractTermType {
+    conversionFunction = Maybe.empty();
     filterFunction = code `${this.reusables.snippets.filterTerm}`;
     filterType = code `${this.reusables.snippets.TermFilter}`;
     kind = "TermType";
@@ -23,17 +25,6 @@ export class TermType extends AbstractTermType {
         invariant(this.nodeKinds.has("Literal") &&
             (this.nodeKinds.has("BlankNode") || this.nodeKinds.has("IRI")), "should be IdentifierType or LiteralType");
     }
-    get conversionFunction() {
-        return {
-            code: code `${this.reusables.snippets.convertToTerm}<${this.name}>`,
-            sourceTypes: [
-                {
-                    name: this.name,
-                    typeof: "object",
-                },
-            ],
-        };
-    }
     get graphqlType() {
         throw new Error("not implemented");
     }
@@ -55,7 +46,9 @@ export class TermType extends AbstractTermType {
             .map((import_) => code `${import_}`), { on: " | " })})`;
     }
     fromJsonExpression({ variables, }) {
-        return [...this.nodeKinds].reduce((expression, nodeKind) => {
+        return code `${this.reusables.imports.Either}.of<Error, ${this.name}>(${[
+            ...this.nodeKinds,
+        ].reduce((expression, nodeKind) => {
             let valueToNodeKind;
             switch (nodeKind) {
                 case "BlankNode":
@@ -73,7 +66,7 @@ export class TermType extends AbstractTermType {
             return expression == null
                 ? valueToNodeKind
                 : code `((${variables.value}.termType === "${NodeKind.toTermType(nodeKind)}") ? (${valueToNodeKind}) : (${expression}))`;
-        }, null);
+        }, null)})`;
     }
     graphqlResolveExpression(_parameters) {
         throw new Error("not implemented");
@@ -119,9 +112,6 @@ export class TermType extends AbstractTermType {
         }, null);
     }
 }
-__decorate([
-    Memoize()
-], TermType.prototype, "conversionFunction", null);
 __decorate([
     Memoize()
 ], TermType.prototype, "name", null);

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/IdentifierProperty.js

@@ -23,7 +23,8 @@ export class IdentifierProperty extends AbstractProperty {
     get constructorParameter() {
         let hasQuestionToken = false;
         const typeNames = [code `(() => ${this.typeAlias})`];
-        for (const type of this.type.conversionFunction.sourceTypes) {
+        for (const type of this.type.conversionFunction.unsafeCoerce()
+            .sourceTypes) {
             if (type.typeof === "undefined") {
                 hasQuestionToken = true;
             }

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,22 +1,43 @@
 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();
     }
-    let initializers = [];
-    const statements = [];
     const variables = {
         jsonObject: code `${this.configuration.syntheticNamePrefix}json`,
     };
-    this.parentObjectTypes.forEach((parentObjectType) => {
-        initializers.push(code `...${parentObjectType.name}.fromJson(${variables.jsonObject})`);
+    const chains = [];
+    this.parentObjectTypes.forEach((parentObjectType, parentObjectTypeI) => {
+        chains.push({
+            expression: code `${parentObjectType.name}.fromJson(${variables.jsonObject})`,
+            variable: `super${parentObjectTypeI}`,
+        });
     });
-    initializers = initializers.concat(this.properties.flatMap((property) => property.fromJsonInitializer({ variables }).toList()));
-    statements.push(code `return createUnsafe({ ${joinCode(initializers, { on: ", " })} });`);
+    const propertyInitializers = this.properties.flatMap((property) => property.fromJsonInitializer({ variables }).toList());
+    if (propertyInitializers.length > 0) {
+        chains.push({
+            expression: code `${this.reusables.snippets.sequenceRecord}({ ${joinCode(propertyInitializers, { on: "," })} })`,
+            variable: "properties",
+        });
+    }
+    let returnExpression;
+    switch (chains.length) {
+        case 0:
+            returnExpression = code `create({})`;
+            break;
+        case 1:
+            returnExpression = code `(${chains[0].expression}).chain(create)`;
+            break;
+        default:
+            returnExpression = code `${chains
+                .reverse()
+                .reduce((acc, { expression, variable }) => code `(${expression}).chain(${variable} => ${acc})`, code `(create({ ${chains.map((chain) => `...${chain.variable}`).join(", ")} }))`)}`;
+            break;
+    }
     return Maybe.of(code `\
-export function fromJson(${variables.jsonObject}: ${this.jsonType().name}): ${this.name} {
-${joinCode(statements, { on: "\n" })}
+export function fromJson(${variables.jsonObject}: ${this.jsonType().name}): ${this.reusables.imports.Either}<Error, ${this.name}> {
+  return ${returnExpression};
 }`);
 }
 //# sourceMappingURL=NamedObjectType_fromJsonFunctionDeclaration.js.map

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;
@@ -84,19 +84,19 @@ export function NamedObjectType_fromRdfResourceFunctionDeclaration() {
             partialsJoined = code `{ ${partials.map((partial) => `...${partial}`).join(", ")} }`;
             break;
     }
-    const statements = [];
+    let returnExpression;
     const resultExpression = code `create(${partialsJoined})`;
     if (chains.length === 0) {
-        statements.push(code `return ${this.reusables.imports.Right}(${resultExpression});`);
+        returnExpression = code `${this.reusables.imports.Right}(${resultExpression})`;
     }
     else {
-        statements.push(code `return ${chains
+        returnExpression = code `${chains
             .reverse()
-            .reduce((acc, { expression, variable }) => code `(${expression}).chain(${variable} => ${acc})`, code `(${resultExpression})`)}`);
+            .reduce((acc, { expression, variable }) => code `(${expression}).chain(${variable} => ${acc})`, code `(${resultExpression})`)}`;
     }
     return Maybe.of(code `\
 export const _fromRdfResource: ${this.reusables.snippets._FromRdfResourceFunction}<${this.name}> = (${variables.resource}, ${optionsVariable}) => {
-${joinCode(statements)}
+  return ${returnExpression};
 }
 
 export const fromRdfResource = ${this.reusables.snippets.wrap_FromRdfResourceFunction}(_fromRdfResource);`);

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 = [];

package/dist/generators/ts/_NamedObjectType/NamedObjectType_toRdfResourceFunctionDeclaration.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_toRdfResourceFunctionDeclaration() {
-    if (!this.configuration.features.has("rdf")) {
+    if (!this.configuration.features.has("Object.toRdf")) {
         return Maybe.empty();
     }
     const statements = this.parentObjectTypes.map((parentObjectType) => code `${parentObjectType.name}._toRdfResource({ ...parameters, ignoreRdfType: true });`);

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

@@ -1,5 +1,8 @@
 import { code, joinCode } from "../ts-poet-wrapper.js";
 export function NamedObjectType_toStringFunctionDeclarations() {
+    if (!this.configuration.features.has("Object.toString")) {
+        return [];
+    }
     let propertiesToStringInitializers = [];
     if (this.parentObjectTypes.length > 0) {
         for (const parentObjectType of this.parentObjectTypes) {

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

@@ -1,7 +1,7 @@
 import { Maybe } from "purify-ts";
 import { code } from "../ts-poet-wrapper.js";
 export function NamedObjectType_valueSparqlConstructTriplesFunctionDeclaration() {
-    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_valueSparqlWherePatternsFunctionDeclaration.js

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