@shaclmate/compiler 4.0.41 → 4.0.43

package/dist/generators/ts/ZodGenerator.js

@@ -1,5 +1,5 @@
-import { ObjectType_jsonSchemaFunctionDeclaration } from "./_ObjectType/ObjectType_jsonSchemaFunctionDeclaration.js";
-import { ObjectType_jsonTypeAliasDeclaration } from "./_ObjectType/ObjectType_jsonTypeAliasDeclaration.js";
+import { ObjectType_jsonSchemaExpression } from "./_ObjectType/ObjectType_jsonSchemaExpression.js";
+import { ObjectType_jsonTypeExpression } from "./_ObjectType/ObjectType_jsonTypeExpression.js";
 import { Reusables } from "./Reusables.js";
 import { TsGenerator } from "./TsGenerator.js";
 import { TypeFactory } from "./TypeFactory.js";
@@ -20,14 +20,16 @@ export class ZodGenerator {
         const declarations = [];
         for (const astNamedType of ast_.namedTypes) {
             switch (astNamedType.kind) {
-                case "Object": {
+                case "Struct": {
                     const tsNamedObjectType = typeFactory.createObjectType(astNamedType);
                     declarations.push(code `\
-export namespace ${tsNamedObjectType.alias.unsafeCoerce()} {
-  ${joinCode(ObjectType_jsonTypeAliasDeclaration.call(tsNamedObjectType).toList())}
+export namespace ${tsNamedObjectType.name.unsafeCoerce()} {
+  export type Json = ${ObjectType_jsonTypeExpression.call(tsNamedObjectType)};
 
   export namespace Json {
-    ${joinCode(ObjectType_jsonSchemaFunctionDeclaration.call(tsNamedObjectType).toList())}
+    export function schema() {
+      return ${ObjectType_jsonSchemaExpression.call(tsNamedObjectType)};
+    }
   }
 }`);
                     break;
@@ -35,7 +37,7 @@ export namespace ${tsNamedObjectType.alias.unsafeCoerce()} {
                 case "Union": {
                     const tsNamedUnionType = typeFactory.createUnionType(astNamedType);
                     declarations.push(code `\
-export namespace ${tsNamedUnionType.alias.unsafeCoerce()} {
+export namespace ${tsNamedUnionType.name.unsafeCoerce()} {
   ${tsNamedUnionType.jsonTypeAliasDeclaration}
   export namespace Json {
     ${tsNamedUnionType.jsonSchemaFunctionDeclaration}
@@ -43,6 +45,12 @@ export namespace ${tsNamedUnionType.alias.unsafeCoerce()} {
 }`);
                     break;
                 }
+                default: {
+                    const type = typeFactory.createType(astNamedType);
+                    type.declaration.ifJust((declaration) => {
+                        declarations.push(declaration);
+                    });
+                }
             }
         }
         declarations.splice(0, 0, joinCode(reusables.snippets.ifUsed, { on: "\n\n" }));

package/dist/generators/ts/_ObjectType/AbstractProperty.d.ts

@@ -1,4 +1,4 @@
-import { Maybe } from "purify-ts";
+import type { Maybe } from "purify-ts";
 import type { Logger } from "ts-log";
 import type { Reusables } from "../Reusables.js";
 import { rdfjsTermExpression } from "../rdfjsTermExpression.js";
@@ -9,19 +9,22 @@ export declare abstract class AbstractProperty<TypeT extends Pick<Type, "express
     protected readonly configuration: TsGenerator.Configuration;
     protected readonly logger: Logger;
     protected readonly objectType: {
-        readonly alias: Maybe<string>;
+        readonly name: Maybe<string>;
     };
     protected readonly reusables: Reusables;
     /**
      * Optional parameter to include in the parameters object of constructor function.
      */
-    abstract readonly constructorParameter: Maybe<Code>;
+    abstract readonly constructorParameter: Maybe<{
+        readonly hasQuestionToken: boolean;
+        readonly signature: Code;
+    }>;
     /**
-     * Property declaration to include in a class or interface declaration of the object type.
+     * Property declaration to include in the type declaration of the ObjectType.
      */
     abstract readonly declaration: Code;
     /**
-     * Optional property in the object type's filter.
+     * Optional property in the ObjectType's filter.
      */
     abstract readonly filterProperty: Maybe<{
         readonly name: string;
@@ -39,6 +42,12 @@ export declare abstract class AbstractProperty<TypeT extends Pick<Type, "express
         resolve: Code;
         type: Code;
     }>;
+    /**
+     * Parameter to include in the expression of the ObjectType passed to its hash function.
+     *
+     * Only specified if different from declaration.
+     */
+    abstract readonly hashFunctionParameter: Code;
     /**
      * zod object key: schema.
      */
@@ -66,6 +75,14 @@ export declare abstract class AbstractProperty<TypeT extends Pick<Type, "express
      * Is the property's type the ObjectType or does its type indirectly reference the ObjectType?
      */
     abstract readonly recursive: boolean;
+    /**
+     * TypeScript object describing this type, for runtime use.
+     */
+    abstract readonly schema: Maybe<Code>;
+    /**
+     * TypeScript type describing .schema.
+     */
+    abstract readonly schemaType: Maybe<Code>;
     /**
      * Property type
   .   */
@@ -75,19 +92,11 @@ export declare abstract class AbstractProperty<TypeT extends Pick<Type, "express
         logger: Logger;
         name: string;
         objectType: {
-            readonly alias: Maybe<string>;
+            readonly name: Maybe<string>;
         };
         reusables: Reusables;
         type: TypeT;
     });
-    /**
-     * TypeScript object describing this type, for runtime use.
-     */
-    get schema(): Maybe<Code>;
-    /**
-     * Helper to compose the result of schema along the type hierarchy.
-     */
-    protected get schemaInitializers(): readonly Code[];
     /**
      * Expression to access the value of this property on an object instance. May evaluate a thunk.
      */
@@ -118,10 +127,10 @@ export declare abstract class AbstractProperty<TypeT extends Pick<Type, "express
     abstract fromRdfResourceValuesInitializer(parameters: {
         variables: {
             context: Code;
+            focusResource: Code;
             graph: Code;
             objectSet: Code;
             preferredLanguages: Code;
-            resource: Code;
         };
     }): Maybe<Code>;
     /**

package/dist/generators/ts/_ObjectType/AbstractProperty.js

@@ -1,13 +1,5 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-import { Maybe } from "purify-ts";
-import { Memoize } from "typescript-memoize";
 import { rdfjsTermExpression } from "../rdfjsTermExpression.js";
-import { code, joinCode, literalOf } from "../ts-poet-wrapper.js";
+import { code } from "../ts-poet-wrapper.js";
 export class AbstractProperty {
     configuration;
     logger;
@@ -34,18 +26,6 @@ export class AbstractProperty {
             snippets: this.reusables.snippets,
         });
     }
-    /**
-     * TypeScript object describing this type, for runtime use.
-     */
-    get schema() {
-        return Maybe.of(code `{ ${joinCode(this.schemaInitializers.concat(), { on: ", " })} }`);
-    }
-    /**
-     * Helper to compose the result of schema along the type hierarchy.
-     */
-    get schemaInitializers() {
-        return [code `kind: ${literalOf(this.kind)}`];
-    }
     /**
      * Expression to access the value of this property on an object instance. May evaluate a thunk.
      */
@@ -54,7 +34,4 @@ export class AbstractProperty {
     }
     rdfjsTermExpression;
 }
-__decorate([
-    Memoize()
-], AbstractProperty.prototype, "schema", null);
 //# sourceMappingURL=AbstractProperty.js.map

package/dist/generators/ts/_ObjectType/DiscriminantProperty.d.ts

@@ -2,21 +2,24 @@ import { Maybe } from "purify-ts";
 import { type Code } from "../ts-poet-wrapper.js";
 import { AbstractProperty } from "./AbstractProperty.js";
 export declare class DiscriminantProperty extends AbstractProperty<DiscriminantProperty.Type> {
-    readonly constructorParameter: Maybe<Code>;
+    readonly constructorParameter: AbstractProperty<DiscriminantProperty.Type>["constructorParameter"];
+    readonly declaration: Code;
     readonly filterProperty: AbstractProperty<DiscriminantProperty.Type>["filterProperty"];
     readonly graphqlField: AbstractProperty<DiscriminantProperty.Type>["graphqlField"];
+    readonly hashFunctionParameter: Code;
+    readonly jsonName = "@type";
+    readonly jsonSignature: Maybe<Code>;
     readonly kind = "Discriminant";
     readonly mutable = false;
     readonly recursive = false;
+    readonly schema: Maybe<Code>;
+    readonly schemaType: Maybe<Code>;
     readonly value: string;
     constructor({ value, ...superParameters }: {
         value: string;
     } & Omit<ConstructorParameters<typeof AbstractProperty>[0], "type">);
-    get declaration(): Code;
-    get jsonName(): string;
     get jsonSchema(): AbstractProperty<DiscriminantProperty.Type>["jsonSchema"];
-    get jsonSignature(): Maybe<Code>;
-    get schema(): Maybe<Code>;
+    get values(): readonly string[];
     private get constValue();
     constructorInitializer(): Maybe<Code>;
     fromJsonInitializer(): Maybe<Code>;
@@ -28,7 +31,6 @@ export declare class DiscriminantProperty extends AbstractProperty<DiscriminantP
     toJsonInitializer({ variables, }: Parameters<AbstractProperty<DiscriminantProperty.Type>["toJsonInitializer"]>[0]): Maybe<Code>;
     toRdfRdfResourceValuesStatements(): readonly Code[];
     toStringInitializer(): Maybe<Code>;
-    get values(): readonly string[];
 }
 export declare namespace DiscriminantProperty {
     class Type {

package/dist/generators/ts/_ObjectType/DiscriminantProperty.js

@@ -10,37 +10,31 @@ import { code, literalOf } from "../ts-poet-wrapper.js";
 import { AbstractProperty } from "./AbstractProperty.js";
 export class DiscriminantProperty extends AbstractProperty {
     constructorParameter = Maybe.empty();
+    declaration = code `readonly ${this.name}: ${this.type.expression};`;
     filterProperty = Maybe.empty();
     graphqlField = Maybe.empty();
+    hashFunctionParameter = code `readonly ${this.name}?: ${this.type.expression};`;
+    jsonName = "@type";
+    jsonSignature = Maybe.of(code `readonly "${this.jsonName}": ${this.type.expression}`);
     kind = "Discriminant";
     mutable = false;
     recursive = false;
+    schema = Maybe.empty();
+    schemaType = Maybe.empty();
     value;
     constructor({ value, ...superParameters }) {
         super({ ...superParameters, type: new DiscriminantProperty.Type(value) });
         this.value = value;
     }
-    get declaration() {
-        return code `readonly ${this.name}: ${this.type.expression};`;
-    }
-    get jsonName() {
-        return "@type";
-    }
     get jsonSchema() {
         return Maybe.of({
             key: this.jsonName,
             schema: code `${this.reusables.imports.z}.literal(${literalOf(this.value)})`,
         });
     }
-    get jsonSignature() {
-        return Maybe.of(code `readonly "${this.jsonName}": ${this.type.expression}`);
-    }
-    get schema() {
-        return Maybe.empty();
+    get values() {
+        return [this.value];
     }
-    // protected override get schemaInitializers(): readonly Code[] {
-    //   return super.schemaInitializers.concat(code`type: ${this.type.schema}`);
-    // }
     get constValue() {
         return code `${literalOf(this.value)} as const`;
     }
@@ -54,7 +48,9 @@ export class DiscriminantProperty extends AbstractProperty {
         return Maybe.empty();
     }
     hashStatements({ variables, }) {
-        return [code `${variables.hasher}.update(${variables.value});`];
+        return [
+            code `if (${variables.value}) { ${variables.hasher}.update(${variables.value}); }`,
+        ];
     }
     jsonUiSchemaElement({ variables, }) {
         const scope = code `\`\${${variables.scopePrefix}}/properties/${this.jsonName}\``;
@@ -75,19 +71,10 @@ export class DiscriminantProperty extends AbstractProperty {
     toStringInitializer() {
         return Maybe.empty();
     }
-    get values() {
-        return [this.value];
-    }
 }
-__decorate([
-    Memoize()
-], DiscriminantProperty.prototype, "jsonName", null);
 __decorate([
     Memoize()
 ], DiscriminantProperty.prototype, "jsonSchema", null);
-__decorate([
-    Memoize()
-], DiscriminantProperty.prototype, "jsonSignature", null);
 __decorate([
     Memoize()
 ], DiscriminantProperty.prototype, "values", null);

package/dist/generators/ts/_ObjectType/IdentifierProperty.d.ts

@@ -8,17 +8,23 @@ export declare class IdentifierProperty extends AbstractProperty<BlankNodeType |
     readonly kind = "Identifier";
     readonly mutable = false;
     readonly recursive = false;
-    get constructorParameter(): Maybe<Code>;
+    get constructorParameter(): Maybe<{
+        hasQuestionToken: boolean;
+        signature: Code;
+    }>;
     get declaration(): Code;
     get filterProperty(): Maybe<{
         name: string;
         type: Code;
     }>;
     get graphqlField(): AbstractProperty<IdentifierType>["graphqlField"];
+    get hashFunctionParameter(): Code;
     get jsonSchema(): AbstractProperty<IdentifierType>["jsonSchema"];
     get jsonSignature(): Maybe<Code>;
-    protected get schemaInitializers(): readonly Code[];
+    get schema(): Maybe<Code>;
+    get schemaType(): Maybe<Code>;
     private get typeExpression();
+    private get typeSchemaVariable();
     accessExpression({ variables, }: Parameters<AbstractProperty<BlankNodeType | IdentifierType | IriType>["accessExpression"]>[0]): Code;
     constructorInitializer({ variables, }: Parameters<AbstractProperty<IdentifierType>["constructorInitializer"]>[0]): Maybe<Code>;
     fromJsonInitializer({ variables, }: Parameters<AbstractProperty<IdentifierType>["fromJsonInitializer"]>[0]): Maybe<Code>;

package/dist/generators/ts/_ObjectType/IdentifierProperty.js

@@ -27,7 +27,10 @@ export class IdentifierProperty extends AbstractProperty {
                 typeExpressions.push(code `${type.expression}`);
             }
         }
-        return Maybe.of(code `readonly ${this.name}${hasQuestionToken ? "?" : ""}: ${joinCode(typeExpressions, { on: "|" })};`);
+        return Maybe.of({
+            hasQuestionToken,
+            signature: code `readonly ${this.name}${hasQuestionToken ? "?" : ""}: ${joinCode(typeExpressions, { on: "|" })};`,
+        });
     }
     get declaration() {
         return code `readonly ${this.name}: () => ${this.typeExpression};`;
@@ -45,10 +48,13 @@ export class IdentifierProperty extends AbstractProperty {
             args: Maybe.empty(),
             description: Maybe.empty(),
             name: `_${this.name.substring(syntheticNamePrefix.length)}`,
-            resolve: code `(source) => ${this.typeExpression}.stringify(${this.accessExpression({ variables: { object: code `source` } })})`,
+            resolve: code `(source) => ${this.type.stringifyFunction}(${this.accessExpression({ variables: { object: code `source` } })})`,
             type: this.type.graphqlType.expression,
         });
     }
+    get hashFunctionParameter() {
+        return code `readonly ${this.name}?: () => ${this.typeExpression};`;
+    }
     get jsonSchema() {
         let schema;
         if (this.type.in_.length > 0 && this.type.kind === "Iri") {
@@ -70,14 +76,25 @@ export class IdentifierProperty extends AbstractProperty {
         }
         return Maybe.of(code `readonly "@id": string`);
     }
-    get schemaInitializers() {
-        return super.schemaInitializers.concat(code `type: ${this.type.schema}`);
+    get schema() {
+        return Maybe.of(code `{ ${joinCode([code `kind: ${literalOf(this.kind)}`, code `type: ${this.type.schema}`], { on: ", " })} }`);
+    }
+    get schemaType() {
+        return Maybe.of(code `{ ${joinCode([
+            code `readonly kind: ${literalOf(this.kind)}`,
+            code `readonly type: ${this.type.schemaType}`,
+        ], { on: ", " })} }`);
     }
     get typeExpression() {
-        return this.objectType.alias
+        return this.objectType.name
             .map((objectTypeAlias) => code `${objectTypeAlias}.Identifier`)
             .orDefault(this.type.expression);
     }
+    get typeSchemaVariable() {
+        return this.objectType.name
+            .map((name) => code `${name}.schema.properties.${this.name}.type`)
+            .orDefaultLazy(() => this.type.schema);
+    }
     accessExpression({ variables, }) {
         return code `${variables.object}.${this.name}()`;
     }
@@ -106,16 +123,26 @@ export class IdentifierProperty extends AbstractProperty {
         })}`);
     }
     fromRdfResourceValuesInitializer({ variables, }) {
-        return Maybe.of(code `${this.name}: ${this.type.fromRdfResourceValuesExpression({
-            variables: {
-                ...variables,
-                propertyPath: this.rdfjsTermExpression(rdf.subject),
-                resourceValues: code `${this.reusables.imports.Right}(new ${this.reusables.imports.Resource}.Value(${{ dataFactory: this.reusables.imports.dataFactory, focusResource: variables.resource, propertyPath: this.rdfjsTermExpression(rdf.subject), term: code `${variables.resource}.identifier` }}).toValues())`,
-            },
-        })}.chain(values => values.head())`);
+        const options = {
+            context: variables.context,
+            graph: variables.graph,
+            focusResource: variables.focusResource,
+            preferredLanguages: variables.preferredLanguages,
+            propertyPath: this.rdfjsTermExpression(rdf.subject),
+            schema: this.typeSchemaVariable,
+        };
+        if (this.configuration.features.has("ObjectSet")) {
+            options["objectSet"] = variables.objectSet;
+        }
+        return Maybe.of(code `${this.name}: ${this.type.fromRdfResourceValuesFunction}(
+          new ${this.reusables.imports.Resource}.Value(${{ dataFactory: this.reusables.imports.dataFactory, focusResource: variables.focusResource, propertyPath: this.rdfjsTermExpression(rdf.subject), term: code `${variables.focusResource}.identifier` }}).toValues(),
+          ${options}
+        ).chain(values => values.head())`);
     }
     hashStatements({ variables, }) {
-        return [code `${variables.hasher}.update(${variables.value}.value);`];
+        return [
+            code `if (${variables.value}) { ${variables.hasher}.update(${variables.value}().value); }`,
+        ];
     }
     jsonUiSchemaElement({ variables, }) {
         return Maybe.of(code `{ label: "Identifier", scope: \`\${${variables.scopePrefix}}/properties/@id\`, type: "Control" }`);
@@ -131,9 +158,7 @@ export class IdentifierProperty extends AbstractProperty {
                 ignoreRdfType: true, // Unused
                 preferredLanguages: variables.preferredLanguages,
                 propertyPatterns: code `[]`,
-                schema: this.objectType.alias
-                    .map((objectTypeAlias) => code `${objectTypeAlias}.schema.properties.${this.name}.type`)
-                    .orDefault(this.type.schema),
+                schema: this.typeSchemaVariable,
                 valueVariable: variables.focusIdentifier,
                 variablePrefix: variables.variablePrefix, // Unused
             }})`,
@@ -176,6 +201,9 @@ __decorate([
 __decorate([
     Memoize()
 ], IdentifierProperty.prototype, "graphqlField", null);
+__decorate([
+    Memoize()
+], IdentifierProperty.prototype, "hashFunctionParameter", null);
 __decorate([
     Memoize()
 ], IdentifierProperty.prototype, "jsonSchema", null);

package/dist/generators/ts/_ObjectType/ObjectType_createFunctionExpression.d.ts

@@ -0,0 +1,4 @@
+import type { ObjectType } from "../ObjectType.js";
+import { type Code } from "../ts-poet-wrapper.js";
+export declare function ObjectType_createFunctionExpression(this: ObjectType): Code;
+//# sourceMappingURL=ObjectType_createFunctionExpression.d.ts.map

package/dist/generators/ts/_ObjectType/ObjectType_createFunctionExpression.js

@@ -0,0 +1,28 @@
+import { invariant } from "ts-invariant";
+import { code, joinCode, literalOf } from "../ts-poet-wrapper.js";
+export function ObjectType_createFunctionExpression() {
+    const parametersVariable = code `parameters${this.constructorParameters.hasQuestionToken ? "?" : ""}`;
+    const propertyInitializers = this.properties.flatMap((property) => property
+        .constructorInitializer({
+        variables: { parameters: parametersVariable },
+    })
+        .toList());
+    invariant(propertyInitializers.length > 0);
+    let returnExpression = code `${this.reusables.snippets.sequenceRecord}({ ${joinCode(propertyInitializers, { on: "," })} })`;
+    this.discriminantProperty.ifJust((discriminantProperty) => {
+        returnExpression = code `${returnExpression}.map(properties => ({ ...properties, ${discriminantProperty.name}: ${literalOf(discriminantProperty.value)} as const }))`;
+    });
+    const monkeyPatchMethods = {};
+    if (this.configuration.features.has("Object.toJson")) {
+        monkeyPatchMethods["toJson"] = this.toJsonFunction;
+    }
+    if (this.configuration.features.has("Object.toString")) {
+        monkeyPatchMethods[`${this.configuration.syntheticNamePrefix}toString`] =
+            this.toStringFunction;
+    }
+    if (Object.keys(monkeyPatchMethods).length > 0) {
+        returnExpression = code `${returnExpression}.map(object => ${this.reusables.snippets.monkeyPatchObject}(object, ${monkeyPatchMethods}))`;
+    }
+    return code `((parameters${this.name.map(() => code ``).orDefaultLazy(() => code `: ${this.constructorParameters.type.expression}`)}) => ${returnExpression})`;
+}
+//# sourceMappingURL=ObjectType_createFunctionExpression.js.map

package/dist/generators/ts/_ObjectType/ObjectType_equalsFunctionExpression.d.ts

@@ -0,0 +1,4 @@
+import type { ObjectType } from "../ObjectType.js";
+import { type Code } from "../ts-poet-wrapper.js";
+export declare function ObjectType_equalsFunctionExpression(this: ObjectType): Code;
+//# sourceMappingURL=ObjectType_equalsFunctionExpression.d.ts.map

package/dist/generators/ts/_ObjectType/{ObjectType_equalsFunctionDeclaration.js → ObjectType_equalsFunctionExpression.js}

@@ -1,9 +1,5 @@
-import { Maybe } from "purify-ts";
 import { code, joinCode } from "../ts-poet-wrapper.js";
-export function ObjectType_equalsFunctionDeclaration() {
-    if (!this.configuration.features.has("Object.equals")) {
-        return Maybe.empty();
-    }
+export function ObjectType_equalsFunctionExpression() {
     const chain = [];
     for (const property of this.properties) {
         if (property.kind === "Discriminant") {
@@ -11,9 +7,9 @@ export function ObjectType_equalsFunctionDeclaration() {
         }
         chain.push(code `(${property.type.equalsFunction})(${property.accessExpression({ variables: { object: code `left` } })}, ${property.accessExpression({ variables: { object: code `right` } })}).mapLeft(propertyValuesUnequal => ({ left, right, propertyName: "${property.name}", propertyValuesUnequal, type: "property" as const }))`);
     }
-    return Maybe.of(code `\
-export function equals(left: ${this.expression}, right: ${this.expression}): ${this.reusables.snippets.EqualsResult} {
-  return ${joinCode(chain.map((chainPart, chainPartI) => chainPartI === 0 ? chainPart : code `chain(() => ${chainPart})`), { on: "." })}
-}`);
+    return code `\
+((left, right) =>
+  ${joinCode(chain.map((chainPart, chainPartI) => chainPartI === 0 ? chainPart : code `chain(() => ${chainPart})`), { on: "." })}
+)`;
 }
-//# sourceMappingURL=ObjectType_equalsFunctionDeclaration.js.map
+//# sourceMappingURL=ObjectType_equalsFunctionExpression.js.map

package/dist/generators/ts/_ObjectType/ObjectType_filterFunctionExpression.d.ts

@@ -0,0 +1,4 @@
+import type { ObjectType } from "../ObjectType.js";
+import { type Code } from "../ts-poet-wrapper.js";
+export declare function ObjectType_filterFunctionExpression(this: ObjectType): Code;
+//# sourceMappingURL=ObjectType_filterFunctionExpression.d.ts.map

package/dist/generators/ts/_ObjectType/ObjectType_filterFunctionExpression.js

@@ -0,0 +1,12 @@
+import { code, joinCode } from "../ts-poet-wrapper.js";
+export function ObjectType_filterFunctionExpression() {
+    const statements = [];
+    for (const property of this.properties) {
+        property.filterProperty.ifJust(({ name }) => {
+            statements.push(code `if (filter.${name} !== undefined && !${property.type.filterFunction}(filter.${name}, ${property.accessExpression({ variables: { object: code `value` } })})) { return false; }`);
+        });
+    }
+    statements.push(code `return true;`);
+    return code `((filter, value) => { ${joinCode(statements)} })`;
+}
+//# sourceMappingURL=ObjectType_filterFunctionExpression.js.map

package/dist/generators/ts/_ObjectType/ObjectType_filterTypeExpression.d.ts

@@ -0,0 +1,4 @@
+import type { ObjectType } from "../ObjectType.js";
+import { type Code } from "../ts-poet-wrapper.js";
+export declare function ObjectType_filterTypeExpression(this: ObjectType): Code;
+//# sourceMappingURL=ObjectType_filterTypeExpression.d.ts.map

package/dist/generators/ts/_ObjectType/{ObjectType_filterTypeDeclaration.js → ObjectType_filterTypeExpression.js}

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

package/dist/generators/ts/_ObjectType/{ObjectType_focusSparqlConstructTriplesFunctionDeclaration.d.ts → ObjectType_focusSparqlConstructTriplesFunctionExpression.d.ts}

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

package/dist/generators/ts/_ObjectType/{ObjectType_focusSparqlConstructTriplesFunctionDeclaration.js → ObjectType_focusSparqlConstructTriplesFunctionExpression.js}

@@ -1,15 +1,11 @@
 import { rdf, rdfs } from "@tpluscode/rdf-ns-builders";
-import { Maybe } from "purify-ts";
 import { code, joinCode } from "../ts-poet-wrapper.js";
 const variables = {
     filter: code `parameters.filter`,
     focusIdentifier: code `parameters.focusIdentifier`,
     variablePrefix: code `parameters.variablePrefix`,
 };
-export function ObjectType_focusSparqlConstructTriplesFunctionDeclaration() {
-    if (!this.configuration.features.has("Object.SPARQL")) {
-        return Maybe.empty();
-    }
+export function ObjectType_focusSparqlConstructTriplesFunctionExpression() {
     const rdfClassVariable = code `${this.reusables.imports.dataFactory}.variable!(\`\${${variables.variablePrefix}}RdfClass\`)`;
     const rdfTypeVariable = code `${this.reusables.imports.dataFactory}.variable!(\`\${${variables.variablePrefix}}RdfType\`)`;
     let triplesVariableDeclarationKeyword = "const";
@@ -36,8 +32,8 @@ if (!parameters?.ignoreRdfType) {
             triplesVariableDeclarationKeyword = "let";
         });
     }
-    return Maybe.of(code `\
-export const focusSparqlConstructTriples: ${this.reusables.snippets.FocusSparqlConstructTriplesFunction}<${this.filterType}> = (${statements.length === 0 ? "_" : ""}parameters) => {
+    return code `\
+((${statements.length === 0 ? "_" : ""}parameters) => {
 ${statements.length > 0
         ? joinCode([
             code `${triplesVariableDeclarationKeyword} triples: ${this.reusables.imports.sparqljs}.Triple[] = [];`,
@@ -45,6 +41,6 @@ ${statements.length > 0
             code `return triples;`,
         ])
         : "return [];"}
-};`);
+})`;
 }
-//# sourceMappingURL=ObjectType_focusSparqlConstructTriplesFunctionDeclaration.js.map
+//# sourceMappingURL=ObjectType_focusSparqlConstructTriplesFunctionExpression.js.map

package/dist/generators/ts/_ObjectType/{ObjectType_focusSparqlWherePatternsFunctionDeclaration.d.ts → ObjectType_focusSparqlWherePatternsFunctionExpression.d.ts}

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

package/dist/generators/ts/_ObjectType/{ObjectType_focusSparqlWherePatternsFunctionDeclaration.js → ObjectType_focusSparqlWherePatternsFunctionExpression.js}

@@ -1,5 +1,4 @@
 import { rdf, rdfs } from "@tpluscode/rdf-ns-builders";
-import { Maybe } from "purify-ts";
 import { code, joinCode } from "../ts-poet-wrapper.js";
 const variables = {
     filter: code `parameters.filter`,
@@ -7,10 +6,7 @@ const variables = {
     focusIdentifier: code `parameters.focusIdentifier`,
     variablePrefix: code `parameters.variablePrefix`,
 };
-export function ObjectType_focusSparqlWherePatternsFunctionDeclaration() {
-    if (!this.configuration.features.has("Object.SPARQL")) {
-        return Maybe.empty();
-    }
+export function ObjectType_focusSparqlWherePatternsFunctionExpression() {
     const rdfClassVariable = code `${this.reusables.imports.dataFactory}.variable!(\`\${${variables.variablePrefix}}RdfClass\`)`;
     const rdfTypeVariable = code `${this.reusables.imports.dataFactory}.variable!(\`\${${variables.variablePrefix}}RdfType\`)`;
     let patternsVariableDeclarationKeyword = "const";
@@ -69,8 +65,8 @@ if (!parameters?.ignoreRdfType) {
             patternsVariableDeclarationKeyword = "let";
         });
     }
-    return Maybe.of(code `\
-export const focusSparqlWherePatterns: ${this.reusables.snippets.FocusSparqlWherePatternsFunction}<${this.filterType}> = (${statements.length === 0 ? "_" : ""}parameters) => {
+    return code `\
+((${statements.length === 0 ? "_" : ""}parameters) => {
 ${statements.length > 0
         ? joinCode([
             code `${patternsVariableDeclarationKeyword} patterns: ${this.reusables.snippets.SparqlPattern}[] = [];`,
@@ -78,6 +74,6 @@ ${statements.length > 0
             code `return patterns;`,
         ])
         : "return [];"}
-};`);
+})`;
 }
-//# sourceMappingURL=ObjectType_focusSparqlWherePatternsFunctionDeclaration.js.map
+//# sourceMappingURL=ObjectType_focusSparqlWherePatternsFunctionExpression.js.map