@shaclmate/compiler 4.0.39 → 4.0.41

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

@@ -1,5 +1,5 @@
 import type { Logger } from "ts-log";
-import * as ast from "../../ast/index.js";
+import type * as ast from "../../ast/index.js";
 import type { Generator } from "../Generator.js";
 export declare class ZodGenerator implements Generator {
     private readonly logger;

package/dist/generators/ts/ZodGenerator.js

@@ -1,7 +1,5 @@
-import { invariant } from "ts-invariant";
-import * as ast from "../../ast/index.js";
-import { NamedObjectType_jsonSchemaFunctionDeclaration } from "./_NamedObjectType/NamedObjectType_jsonSchemaFunctionDeclaration.js";
-import { NamedObjectType_jsonTypeAliasDeclaration } from "./_NamedObjectType/NamedObjectType_jsonTypeAliasDeclaration.js";
+import { ObjectType_jsonSchemaFunctionDeclaration } from "./_ObjectType/ObjectType_jsonSchemaFunctionDeclaration.js";
+import { ObjectType_jsonTypeAliasDeclaration } from "./_ObjectType/ObjectType_jsonTypeAliasDeclaration.js";
 import { Reusables } from "./Reusables.js";
 import { TsGenerator } from "./TsGenerator.js";
 import { TypeFactory } from "./TypeFactory.js";
@@ -20,25 +18,32 @@ export class ZodGenerator {
             reusables,
         });
         const declarations = [];
-        for (const namedObjectType of ast.ObjectType.toposort(ast_.namedObjectTypes).map((astObjectType) => typeFactory.createNamedObjectType(astObjectType))) {
-            declarations.push(code `\
-export namespace ${namedObjectType.name} {
-  ${joinCode(NamedObjectType_jsonTypeAliasDeclaration.call(namedObjectType).toList())}
+        for (const astNamedType of ast_.namedTypes) {
+            switch (astNamedType.kind) {
+                case "Object": {
+                    const tsNamedObjectType = typeFactory.createObjectType(astNamedType);
+                    declarations.push(code `\
+export namespace ${tsNamedObjectType.alias.unsafeCoerce()} {
+  ${joinCode(ObjectType_jsonTypeAliasDeclaration.call(tsNamedObjectType).toList())}
 
   export namespace Json {
-    ${joinCode(NamedObjectType_jsonSchemaFunctionDeclaration.call(namedObjectType).toList())}
+    ${joinCode(ObjectType_jsonSchemaFunctionDeclaration.call(tsNamedObjectType).toList())}
   }
 }`);
-        }
-        for (const astNamedUnionType of ast_.namedUnionTypes.map((astNamedUnionType) => typeFactory.createUnionType(astNamedUnionType))) {
-            invariant(astNamedUnionType.kind !== "AnonymousUnion");
-            declarations.push(code `\
-export namespace ${astNamedUnionType.name} {
-  ${astNamedUnionType.jsonTypeAliasDeclaration}
+                    break;
+                }
+                case "Union": {
+                    const tsNamedUnionType = typeFactory.createUnionType(astNamedType);
+                    declarations.push(code `\
+export namespace ${tsNamedUnionType.alias.unsafeCoerce()} {
+  ${tsNamedUnionType.jsonTypeAliasDeclaration}
   export namespace Json {
-    ${astNamedUnionType.jsonSchemaFunctionDeclaration}
+    ${tsNamedUnionType.jsonSchemaFunctionDeclaration}
   }
 }`);
+                    break;
+                }
+            }
         }
         declarations.splice(0, 0, joinCode(reusables.snippets.ifUsed, { on: "\n\n" }));
         return joinCode(declarations, { on: "\n\n" }).toString({});

package/dist/generators/ts/{_NamedObjectType → _ObjectType}/AbstractProperty.d.ts

@@ -1,15 +1,16 @@
 import { Maybe } from "purify-ts";
 import type { Logger } from "ts-log";
-import type { NamedObjectType } from "../NamedObjectType.js";
 import type { Reusables } from "../Reusables.js";
 import { rdfjsTermExpression } from "../rdfjsTermExpression.js";
 import type { TsGenerator } from "../TsGenerator.js";
 import type { Type } from "../Type.js";
 import { type Code } from "../ts-poet-wrapper.js";
-export declare abstract class AbstractProperty<TypeT extends Pick<Type, "filterFunction" | "mutable" | "name" | "schema">> {
+export declare abstract class AbstractProperty<TypeT extends Pick<Type, "expression" | "filterFunction" | "mutable" | "schema">> {
     protected readonly configuration: TsGenerator.Configuration;
     protected readonly logger: Logger;
-    protected readonly namedObjectType: NamedObjectType;
+    protected readonly objectType: {
+        readonly alias: Maybe<string>;
+    };
     protected readonly reusables: Reusables;
     /**
      * Optional parameter to include in the parameters object of constructor function.
@@ -62,18 +63,20 @@ export declare abstract class AbstractProperty<TypeT extends Pick<Type, "filterF
      */
     readonly name: string;
     /**
-     * Is the property's type the NamedObjectType or does its type indirectly reference the NamedObjectType?
+     * Is the property's type the ObjectType or does its type indirectly reference the ObjectType?
      */
     abstract readonly recursive: boolean;
     /**
      * Property type
   .   */
     readonly type: TypeT;
-    constructor({ configuration, logger, name, namedObjectType, reusables, type, }: {
+    constructor({ configuration, logger, name, objectType, reusables, type, }: {
         configuration: TsGenerator.Configuration;
         logger: Logger;
         name: string;
-        namedObjectType: NamedObjectType;
+        objectType: {
+            readonly alias: Maybe<string>;
+        };
         reusables: Reusables;
         type: TypeT;
     });

package/dist/generators/ts/{_NamedObjectType → _ObjectType}/AbstractProperty.js

@@ -11,7 +11,7 @@ import { code, joinCode, literalOf } from "../ts-poet-wrapper.js";
 export class AbstractProperty {
     configuration;
     logger;
-    namedObjectType;
+    objectType;
     reusables;
     /**
      * TypeScript identifier-safe name of the property.
@@ -21,11 +21,11 @@ export class AbstractProperty {
      * Property type
   .   */
     type;
-    constructor({ configuration, logger, name, namedObjectType, reusables, type, }) {
+    constructor({ configuration, logger, name, objectType, reusables, type, }) {
         this.configuration = configuration;
         this.logger = logger;
         this.name = name;
-        this.namedObjectType = namedObjectType;
+        this.objectType = objectType;
         this.reusables = reusables;
         this.type = type;
         this.rdfjsTermExpression = rdfjsTermExpression.bind({

package/dist/generators/ts/{_NamedObjectType → _ObjectType}/DiscriminantProperty.d.ts

@@ -8,9 +8,10 @@ export declare class DiscriminantProperty extends AbstractProperty<DiscriminantP
     readonly kind = "Discriminant";
     readonly mutable = false;
     readonly recursive = false;
-    constructor({ type, ...superParameters }: {
-        type: DiscriminantProperty.Type;
-    } & ConstructorParameters<typeof AbstractProperty>[0]);
+    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"];
@@ -27,21 +28,16 @@ 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 {
+        readonly value: string;
         readonly filterFunction: Code;
-        readonly mutable: boolean;
-        readonly descendantValues: readonly string[];
-        readonly ownValues: readonly string[];
-        constructor({ descendantValues, mutable, ownValues, }: {
-            descendantValues: readonly string[];
-            mutable: boolean;
-            ownValues: readonly string[];
-        });
-        get name(): string;
+        readonly mutable = false;
+        constructor(value: string);
+        get expression(): Code;
         get schema(): Code;
-        get values(): string[];
     }
 }
 //# sourceMappingURL=DiscriminantProperty.d.ts.map

package/dist/generators/ts/{_NamedObjectType → _ObjectType}/DiscriminantProperty.js

@@ -6,7 +6,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 };
 import { Maybe } from "purify-ts";
 import { Memoize } from "typescript-memoize";
-import { arrayOf, code, literalOf } from "../ts-poet-wrapper.js";
+import { code, literalOf } from "../ts-poet-wrapper.js";
 import { AbstractProperty } from "./AbstractProperty.js";
 export class DiscriminantProperty extends AbstractProperty {
     constructorParameter = Maybe.empty();
@@ -15,11 +15,13 @@ export class DiscriminantProperty extends AbstractProperty {
     kind = "Discriminant";
     mutable = false;
     recursive = false;
-    constructor({ type, ...superParameters }) {
-        super({ ...superParameters, type });
+    value;
+    constructor({ value, ...superParameters }) {
+        super({ ...superParameters, type: new DiscriminantProperty.Type(value) });
+        this.value = value;
     }
     get declaration() {
-        return code `readonly ${this.name}: ${this.type.name};`;
+        return code `readonly ${this.name}: ${this.type.expression};`;
     }
     get jsonName() {
         return "@type";
@@ -27,13 +29,11 @@ export class DiscriminantProperty extends AbstractProperty {
     get jsonSchema() {
         return Maybe.of({
             key: this.jsonName,
-            schema: this.type.values.length > 1
-                ? code `${this.reusables.imports.z}.enum(${arrayOf(...this.type.values)})`
-                : code `${this.reusables.imports.z}.literal(${literalOf(this.type.values[0])})`,
+            schema: code `${this.reusables.imports.z}.literal(${literalOf(this.value)})`,
         });
     }
     get jsonSignature() {
-        return Maybe.of(code `readonly "${this.jsonName}": ${this.type.name}`);
+        return Maybe.of(code `readonly "${this.jsonName}": ${this.type.expression}`);
     }
     get schema() {
         return Maybe.empty();
@@ -42,7 +42,7 @@ export class DiscriminantProperty extends AbstractProperty {
     //   return super.schemaInitializers.concat(code`type: ${this.type.schema}`);
     // }
     get constValue() {
-        return code `${literalOf(this.namedObjectType.discriminantValue)} as const`;
+        return code `${literalOf(this.value)} as const`;
     }
     constructorInitializer() {
         return Maybe.empty();
@@ -54,15 +54,9 @@ export class DiscriminantProperty extends AbstractProperty {
         return Maybe.empty();
     }
     hashStatements({ variables, }) {
-        if (this.namedObjectType.parentObjectTypes.length > 0) {
-            return [];
-        }
         return [code `${variables.hasher}.update(${variables.value});`];
     }
     jsonUiSchemaElement({ variables, }) {
-        if (this.namedObjectType.parentObjectTypes.length > 0) {
-            return Maybe.empty();
-        }
         const scope = code `\`\${${variables.scopePrefix}}/properties/${this.jsonName}\``;
         return Maybe.of(code `{ rule: { condition: { schema: { const: ${this.constValue} }, scope: ${scope} }, effect: "HIDE" }, scope: ${scope}, type: "Control" }`);
     }
@@ -81,6 +75,9 @@ export class DiscriminantProperty extends AbstractProperty {
     toStringInitializer() {
         return Maybe.empty();
     }
+    get values() {
+        return [this.value];
+    }
 }
 __decorate([
     Memoize()
@@ -91,44 +88,30 @@ __decorate([
 __decorate([
     Memoize()
 ], DiscriminantProperty.prototype, "jsonSignature", null);
+__decorate([
+    Memoize()
+], DiscriminantProperty.prototype, "values", null);
 (function (DiscriminantProperty) {
     class Type {
+        value;
         filterFunction = code `nonextant`;
-        mutable;
-        descendantValues;
-        ownValues;
-        constructor({ descendantValues, mutable, ownValues, }) {
-            this.descendantValues = descendantValues;
-            this.mutable = mutable;
-            this.ownValues = ownValues;
+        mutable = false;
+        constructor(value) {
+            this.value = value;
         }
-        get name() {
-            return `${this.values.map((name) => `"${name}"`).join(" | ")}`;
+        get expression() {
+            return code `${literalOf(this.value)}`;
         }
         get schema() {
             throw new Error("should never be called");
-            // const initializers: Record<string, unknown> = {};
-            // if (this.descendantValues.length > 0) {
-            //   initializers["descendantValues"] = this.descendantValues;
-            // }
-            // if (this.ownValues.length > 0) {
-            //   initializers["ownValues"] = this.ownValues;
-            // }
-            // return code`${initializers}`;
-        }
-        get values() {
-            return this.ownValues.concat(this.descendantValues);
         }
     }
     __decorate([
         Memoize()
-    ], Type.prototype, "name", null);
+    ], Type.prototype, "expression", null);
     __decorate([
         Memoize()
     ], Type.prototype, "schema", null);
-    __decorate([
-        Memoize()
-    ], Type.prototype, "values", null);
     DiscriminantProperty.Type = Type;
 })(DiscriminantProperty || (DiscriminantProperty = {}));
 //# sourceMappingURL=DiscriminantProperty.js.map

package/dist/generators/ts/{_NamedObjectType → _ObjectType}/IdentifierProperty.d.ts

@@ -5,14 +5,9 @@ import type { IriType } from "../IriType.js";
 import { type Code } from "../ts-poet-wrapper.js";
 import { AbstractProperty } from "./AbstractProperty.js";
 export declare class IdentifierProperty extends AbstractProperty<BlankNodeType | IdentifierType | IriType> {
-    private readonly typeAlias;
     readonly kind = "Identifier";
     readonly mutable = false;
     readonly recursive = false;
-    constructor({ typeAlias, ...superParameters }: {
-        type: BlankNodeType | IdentifierType | IriType;
-        typeAlias: Code;
-    } & ConstructorParameters<typeof AbstractProperty>[0]);
     get constructorParameter(): Maybe<Code>;
     get declaration(): Code;
     get filterProperty(): Maybe<{
@@ -23,6 +18,7 @@ export declare class IdentifierProperty extends AbstractProperty<BlankNodeType |
     get jsonSchema(): AbstractProperty<IdentifierType>["jsonSchema"];
     get jsonSignature(): Maybe<Code>;
     protected get schemaInitializers(): readonly Code[];
+    private get typeExpression();
     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/{_NamedObjectType → _ObjectType}/IdentifierProperty.js

@@ -12,30 +12,25 @@ import { Memoize } from "typescript-memoize";
 import { arrayOf, code, joinCode, literalOf, } from "../ts-poet-wrapper.js";
 import { AbstractProperty } from "./AbstractProperty.js";
 export class IdentifierProperty extends AbstractProperty {
-    typeAlias;
     kind = "Identifier";
     mutable = false;
     recursive = false;
-    constructor({ typeAlias, ...superParameters }) {
-        super(superParameters);
-        this.typeAlias = typeAlias;
-    }
     get constructorParameter() {
         let hasQuestionToken = false;
-        const typeNames = [code `(() => ${this.typeAlias})`];
+        const typeExpressions = [code `(() => ${this.typeExpression})`];
         for (const type of this.type.conversionFunction.unsafeCoerce()
             .sourceTypes) {
-            if (type.typeof === "undefined") {
+            if (type.jsType.typeof === "undefined") {
                 hasQuestionToken = true;
             }
             else {
-                typeNames.push(code `${type.name}`);
+                typeExpressions.push(code `${type.expression}`);
             }
         }
-        return Maybe.of(code `readonly ${this.name}${hasQuestionToken ? "?" : ""}: ${joinCode(typeNames, { on: "|" })};`);
+        return Maybe.of(code `readonly ${this.name}${hasQuestionToken ? "?" : ""}: ${joinCode(typeExpressions, { on: "|" })};`);
     }
     get declaration() {
-        return code `readonly ${this.name}: () => ${this.typeAlias};`;
+        return code `readonly ${this.name}: () => ${this.typeExpression};`;
     }
     get filterProperty() {
         return Maybe.of({
@@ -50,8 +45,8 @@ export class IdentifierProperty extends AbstractProperty {
             args: Maybe.empty(),
             description: Maybe.empty(),
             name: `_${this.name.substring(syntheticNamePrefix.length)}`,
-            resolve: code `(source) => ${this.typeAlias}.stringify(${this.accessExpression({ variables: { object: code `source` } })})`,
-            type: this.type.graphqlType.name,
+            resolve: code `(source) => ${this.typeExpression}.stringify(${this.accessExpression({ variables: { object: code `source` } })})`,
+            type: this.type.graphqlType.expression,
         });
     }
     get jsonSchema() {
@@ -78,6 +73,11 @@ export class IdentifierProperty extends AbstractProperty {
     get schemaInitializers() {
         return super.schemaInitializers.concat(code `type: ${this.type.schema}`);
     }
+    get typeExpression() {
+        return this.objectType.alias
+            .map((objectTypeAlias) => code `${objectTypeAlias}.Identifier`)
+            .orDefault(this.type.expression);
+    }
     accessExpression({ variables, }) {
         return code `${variables.object}.${this.name}()`;
     }
@@ -131,7 +131,9 @@ export class IdentifierProperty extends AbstractProperty {
                 ignoreRdfType: true, // Unused
                 preferredLanguages: variables.preferredLanguages,
                 propertyPatterns: code `[]`,
-                schema: code `${this.namedObjectType.name}.schema.properties.${this.name}.type`,
+                schema: this.objectType.alias
+                    .map((objectTypeAlias) => code `${objectTypeAlias}.schema.properties.${this.name}.type`)
+                    .orDefault(this.type.schema),
                 valueVariable: variables.focusIdentifier,
                 variablePrefix: variables.variablePrefix, // Unused
             }})`,
@@ -180,4 +182,7 @@ __decorate([
 __decorate([
     Memoize()
 ], IdentifierProperty.prototype, "jsonSignature", null);
+__decorate([
+    Memoize()
+], IdentifierProperty.prototype, "typeExpression", null);
 //# sourceMappingURL=IdentifierProperty.js.map

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

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

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

@@ -0,0 +1,44 @@
+import { Maybe } from "purify-ts";
+import { invariant } from "ts-invariant";
+import { code, joinCode, literalOf } from "../ts-poet-wrapper.js";
+export function ObjectType_createFunctionDeclaration() {
+    if (!this.configuration.features.has("Object.create")) {
+        return Maybe.empty();
+    }
+    const parametersPropertySignatures = this.properties.flatMap((property) => property.constructorParameter.toList());
+    const parametersType = parametersPropertySignatures.length > 0
+        ? code `{ ${joinCode(parametersPropertySignatures)} }`
+        : code `object`;
+    const parametersHasQuestionToken = parametersPropertySignatures.every((propertySignature) => propertySignature.toCodeString([]).indexOf("?:") !== -1);
+    const parametersVariable = code `parameters${parametersHasQuestionToken ? "?" : ""}`;
+    const parametersSignature = code `parameters${parametersHasQuestionToken ? "?" : ""}: ${parametersType}`;
+    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.push("toJson");
+    }
+    if (this.configuration.features.has("Object.toString")) {
+        monkeyPatchMethods.push(`${this.configuration.syntheticNamePrefix}toString`);
+    }
+    if (monkeyPatchMethods.length > 0) {
+        returnExpression = code `${returnExpression}.map(object => ${this.reusables.snippets.monkeyPatchObject}(object, { ${monkeyPatchMethods.join(", ")} }))`;
+    }
+    return Maybe.of(code `\
+export function create(${parametersSignature}): ${this.reusables.imports.Either}<Error, ${this.expression}> {
+  return ${returnExpression};
+}
+  
+export function createUnsafe(${parametersSignature}): ${this.expression} {
+  return create(parameters).unsafeCoerce();
+}`);
+}
+//# sourceMappingURL=ObjectType_createFunctionDeclaration.js.map

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

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

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

@@ -1,14 +1,10 @@
 import { Maybe } from "purify-ts";
 import { code, joinCode } from "../ts-poet-wrapper.js";
-export function NamedObjectType_equalsFunctionDeclaration() {
+export function ObjectType_equalsFunctionDeclaration() {
     if (!this.configuration.features.has("Object.equals")) {
         return Maybe.empty();
     }
     const chain = [];
-    // For every parent, find the nearest equals implementation
-    for (const parentObjectType of this.parentObjectTypes) {
-        chain.push(code `${parentObjectType.name}.equals(left, right)`);
-    }
     for (const property of this.properties) {
         if (property.kind === "Discriminant") {
             continue;
@@ -16,8 +12,8 @@ export function NamedObjectType_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.name}, right: ${this.name}): ${this.reusables.snippets.EqualsResult} {
+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: "." })}
 }`);
 }
-//# sourceMappingURL=NamedObjectType_equalsFunctionDeclaration.js.map
+//# sourceMappingURL=ObjectType_equalsFunctionDeclaration.js.map

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

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

package/dist/generators/ts/{_NamedObjectType/NamedObjectType_filterFunctionDeclaration.js → _ObjectType/ObjectType_filterFunctionDeclaration.js}

@@ -1,13 +1,10 @@
 import { Maybe } from "purify-ts";
 import { code, joinCode } from "../ts-poet-wrapper.js";
-export function NamedObjectType_filterFunctionDeclaration() {
+export function ObjectType_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; }`);
-    }
     if (this.properties.length > 0) {
         for (const property of this.properties) {
             property.filterProperty.ifJust(({ name }) => {
@@ -17,8 +14,8 @@ export function NamedObjectType_filterFunctionDeclaration() {
     }
     statements.push(code `return true;`);
     return Maybe.of(code `\
-export function filter(filter: ${this.filterType}, value: ${this.name}): boolean {
+export function filter(filter: ${this.filterType}, value: ${this.expression}): boolean {
   ${joinCode(statements)}
 }`);
 }
-//# sourceMappingURL=NamedObjectType_filterFunctionDeclaration.js.map
+//# sourceMappingURL=ObjectType_filterFunctionDeclaration.js.map

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

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

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

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

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

@@ -0,0 +1,5 @@
+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

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

@@ -6,7 +6,7 @@ const variables = {
     focusIdentifier: code `parameters.focusIdentifier`,
     variablePrefix: code `parameters.variablePrefix`,
 };
-export function NamedObjectType_focusSparqlConstructTriplesFunctionDeclaration() {
+export function ObjectType_focusSparqlConstructTriplesFunctionDeclaration() {
     if (!this.configuration.features.has("Object.SPARQL")) {
         return Maybe.empty();
     }
@@ -14,10 +14,6 @@ export function NamedObjectType_focusSparqlConstructTriplesFunctionDeclaration()
     const rdfTypeVariable = code `${this.reusables.imports.dataFactory}.variable!(\`\${${variables.variablePrefix}}RdfType\`)`;
     let triplesVariableDeclarationKeyword = "const";
     const statements = [];
-    for (const parentObjectType of this.parentObjectTypes) {
-        statements.push(code `triples = triples.concat(${parentObjectType.name}.focusSparqlConstructTriples(${{ filter: variables.filter, focusIdentifier: variables.focusIdentifier, ignoreRdfType: true, variablePrefix: variables.variablePrefix }}));`);
-        triplesVariableDeclarationKeyword = "let";
-    }
     if (this.fromRdfType.isJust()) {
         statements.push(code `\
 if (!parameters?.ignoreRdfType) {
@@ -51,4 +47,4 @@ ${statements.length > 0
         : "return [];"}
 };`);
 }
-//# sourceMappingURL=NamedObjectType_focusSparqlConstructTriplesFunctionDeclaration.js.map
+//# sourceMappingURL=ObjectType_focusSparqlConstructTriplesFunctionDeclaration.js.map

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

@@ -0,0 +1,5 @@
+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