@shaclmate/compiler 3.0.3 → 4.0.0

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

@@ -1,315 +0,0 @@
-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 "ts-morph";
-import { Memoize } from "typescript-memoize";
-import { invariant } from "ts-invariant";
-import { Import } from "../Import.js";
-import { SnippetDeclarations } from "../SnippetDeclarations.js";
-import { Type as _Type } from "../Type.js";
-import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
-import { ShaclProperty } from "./ShaclProperty.js";
-function stubObjectUnionTypeToResolvedObjectUnionTypeSwitchStatement({ resolvedObjectUnionType, stubObjectUnionType, variables, }) {
-    invariant(resolvedObjectUnionType.memberTypes.length ===
-        stubObjectUnionType.memberTypes.length);
-    const caseBlocks = resolvedObjectUnionType.memberTypes.map((resolvedObjectType, objectTypeI) => {
-        return `${resolvedObjectType.discriminatorPropertyValues.map((discriminatorPropertyValue) => `case "${discriminatorPropertyValue}":`).join("\n")} return ${stubObjectUnionType.memberTypes[objectTypeI].newExpression({ parameters: variables.value })};`;
-    });
-    caseBlocks.push(`default: ${variables.value} satisfies never; throw new Error("unrecognized type");`);
-    return `switch (${variables.value}.${resolvedObjectUnionType.discriminatorProperty.unsafeCoerce().name}) { ${caseBlocks.join("\n")} }`;
-}
-export class LazyShaclProperty extends ShaclProperty {
-    mutable = false;
-    recursive = false;
-    get graphqlField() {
-        const args = this.type.graphqlArgs;
-        const argsVariable = args.isJust() ? "args" : "_args";
-        return Maybe.of({
-            args,
-            description: this.comment.map(JSON.stringify),
-            name: this.name,
-            resolve: `async (source, ${argsVariable}) => ${this.type.graphqlResolveExpression({ variables: { args: argsVariable, value: `source.${this.name}` } })}`,
-            type: this.type.graphqlName.toString(),
-        });
-    }
-}
-__decorate([
-    Memoize()
-], LazyShaclProperty.prototype, "graphqlField", null);
-(function (LazyShaclProperty) {
-    class Type extends _Type {
-        discriminatorProperty = Maybe.empty();
-        mutable = false;
-        typeof = "object";
-        resolvedType;
-        runtimeClass;
-        stubType;
-        constructor({ stubType, resolvedType, runtimeClass, }) {
-            super();
-            this.stubType = stubType;
-            this.resolvedType = resolvedType;
-            this.runtimeClass = runtimeClass;
-        }
-        get conversions() {
-            return [
-                {
-                    conversionExpression: (value) => value,
-                    sourceTypeCheckExpression: (value) => `typeof ${value} === "object" && ${value} instanceof ${this.runtimeClass.rawName}`,
-                    sourceTypeName: this.name,
-                },
-            ];
-        }
-        get equalsFunction() {
-            return `((left, right) => ${this.stubType.equalsFunction}(left.${this.runtimeClass.stubPropertyName}, right.${this.runtimeClass.stubPropertyName}))`;
-        }
-        get graphqlName() {
-            return this.resolvedType.graphqlName;
-        }
-        hashStatements({ depth, variables, }) {
-            return this.stubType.hashStatements({
-                depth: depth + 1,
-                variables: {
-                    ...variables,
-                    value: `${variables.value}.${this.runtimeClass.stubPropertyName}`,
-                },
-            });
-        }
-        get jsonName() {
-            return this.stubType.jsonName;
-        }
-        jsonUiSchemaElement(parameters) {
-            return this.stubType.jsonUiSchemaElement(parameters);
-        }
-        jsonZodSchema(parameters) {
-            return this.stubType.jsonZodSchema(parameters);
-        }
-        get name() {
-            return this.runtimeClass.name;
-        }
-        snippetDeclarations(parameters) {
-            return this.stubType
-                .snippetDeclarations(parameters)
-                .concat(this.resolvedType.snippetDeclarations(parameters))
-                .concat(this.runtimeClass.snippetDeclaration);
-        }
-        sparqlConstructTemplateTriples(parameters) {
-            return this.stubType.sparqlConstructTemplateTriples(parameters);
-        }
-        sparqlWherePatterns(parameters) {
-            return this.stubType.sparqlWherePatterns(parameters);
-        }
-        toJsonExpression({ variables, }) {
-            return this.stubType.toJsonExpression({
-                variables: {
-                    value: `${variables.value}.${this.runtimeClass.stubPropertyName}`,
-                },
-            });
-        }
-        toRdfExpression({ variables, }) {
-            return this.stubType.toRdfExpression({
-                variables: {
-                    ...variables,
-                    value: `${variables.value}.${this.runtimeClass.stubPropertyName}`,
-                },
-            });
-        }
-        useImports(parameters) {
-            return this.resolvedType.useImports(parameters).concat(Import.PURIFY);
-        }
-    }
-    __decorate([
-        Memoize()
-    ], Type.prototype, "equalsFunction", null);
-    LazyShaclProperty.Type = Type;
-    class ObjectSetType extends Type {
-        constructor({ resolvedType, stubType, }) {
-            super({
-                resolvedType,
-                runtimeClass: {
-                    name: `${syntheticNamePrefix}LazyObjectSet<${resolvedType.itemType.identifierTypeAlias}, ${resolvedType.itemType.name}, ${stubType.itemType.name}>`,
-                    rawName: `${syntheticNamePrefix}LazyObjectSet`,
-                    snippetDeclaration: SnippetDeclarations.LazyObjectSet,
-                    stubPropertyName: "stubs",
-                },
-                stubType,
-            });
-        }
-        get conversions() {
-            const conversions = super.conversions.concat();
-            if (this.stubType.itemType.kind === "ObjectType") {
-                conversions.push({
-                    conversionExpression: (value) => `new ${this.runtimeClass.name}({ ${this.runtimeClass.stubPropertyName}: ${value}.map(object => ${this.stubType.itemType.newExpression({ parameters: "object" })}), resolver: async () => purify.Either.of(${value} as readonly ${this.resolvedType.itemType.name}[]) })`,
-                    sourceTypeCheckExpression: (value) => `typeof ${value} === "object"`,
-                    sourceTypeName: `readonly ${this.resolvedType.itemType.name}[]`,
-                });
-            }
-            else if (this.resolvedType.itemType.kind === "ObjectUnionType" &&
-                this.stubType.itemType.kind === "ObjectUnionType" &&
-                this.resolvedType.itemType.memberTypes.length ===
-                    this.stubType.itemType.memberTypes.length) {
-                conversions.push({
-                    conversionExpression: (value) => `new ${this.runtimeClass.name}({ ${this.runtimeClass.stubPropertyName}: ${value}.map(object => { ${stubObjectUnionTypeToResolvedObjectUnionTypeSwitchStatement({ resolvedObjectUnionType: this.resolvedType.itemType, stubObjectUnionType: this.stubType.itemType, variables: { value: "object" } })} }), resolver: async () => purify.Either.of(${value} as readonly ${this.resolvedType.itemType.name}[]) })`,
-                    sourceTypeCheckExpression: (value) => `typeof ${value} === "object"`,
-                    sourceTypeName: `readonly ${this.resolvedType.itemType.name}[]`,
-                });
-            }
-            conversions.push({
-                conversionExpression: () => `new ${this.runtimeClass.name}({ ${this.runtimeClass.stubPropertyName}: [], resolver: async () => { throw new Error("should never be called"); } })`,
-                sourceTypeCheckExpression: (value) => `typeof ${value} === "undefined"`,
-                sourceTypeName: "undefined",
-            });
-            return conversions;
-        }
-        fromJsonExpression(parameters) {
-            return `new ${this.runtimeClass.name}({ ${this.runtimeClass.stubPropertyName}: ${this.stubType.fromJsonExpression(parameters)}, resolver: () => Promise.resolve(purify.Left(new Error("unable to resolve identifiers deserialized from JSON"))) })`;
-        }
-        fromRdfExpression(parameters) {
-            const { variables } = parameters;
-            return `${this.stubType.fromRdfExpression(parameters)}.map(values => values.map(${this.runtimeClass.stubPropertyName} => new ${this.runtimeClass.name}({ ${this.runtimeClass.stubPropertyName}, resolver: (identifiers) => ${variables.objectSet}.${this.resolvedType.itemType.objectSetMethodNames.objects}({ where: { identifiers, type: "identifiers" }}) })))`;
-        }
-        get graphqlArgs() {
-            return Maybe.of({
-                limit: {
-                    type: "graphql.GraphQLInt",
-                },
-                offset: {
-                    type: "graphql.GraphQLInt",
-                },
-            });
-        }
-        graphqlResolveExpression({ variables, }) {
-            return `(await ${variables.value}.resolve({ limit: ${variables.args}.limit, offset: ${variables.args}.offset })).unsafeCoerce()`;
-        }
-    }
-    __decorate([
-        Memoize()
-    ], ObjectSetType.prototype, "conversions", null);
-    __decorate([
-        Memoize()
-    ], ObjectSetType.prototype, "graphqlArgs", null);
-    LazyShaclProperty.ObjectSetType = ObjectSetType;
-    class SingleObjectType extends Type {
-        fromJsonExpression(parameters) {
-            return `new ${this.runtimeClass.name}({ ${this.runtimeClass.stubPropertyName}: ${this.stubType.fromJsonExpression(parameters)}, resolver: (identifier) => Promise.resolve(purify.Left(new Error(\`unable to resolve identifier \${rdfjsResource.Resource.Identifier.toString(identifier)} deserialized from JSON\`))) })`;
-        }
-        get graphqlArgs() {
-            return Maybe.empty();
-        }
-        graphqlResolveExpression({ variables, }) {
-            return `(await ${variables.value}.resolve()).unsafeCoerce()`;
-        }
-    }
-    class OptionalObjectType extends SingleObjectType {
-        constructor({ resolvedType, stubType, }) {
-            super({
-                resolvedType,
-                runtimeClass: {
-                    name: `${syntheticNamePrefix}LazyOptionalObject<${resolvedType.itemType.identifierTypeAlias}, ${resolvedType.itemType.name}, ${stubType.itemType.name}>`,
-                    rawName: `${syntheticNamePrefix}LazyOptionalObject`,
-                    snippetDeclaration: SnippetDeclarations.LazyOptionalObject,
-                    stubPropertyName: "stub",
-                },
-                stubType,
-            });
-        }
-        get conversions() {
-            const conversions = super.conversions.concat();
-            if (this.stubType.itemType.kind === "ObjectType") {
-                conversions.push({
-                    conversionExpression: (value) => `new ${this.runtimeClass.name}({ ${this.runtimeClass.stubPropertyName}: ${value}.map(object => ${this.stubType.itemType.newExpression({ parameters: "object" })}), resolver: async () => purify.Either.of((${value} as purify.Maybe<${this.resolvedType.itemType.name}>).unsafeCoerce()) })`,
-                    sourceTypeCheckExpression: (value) => `purify.Maybe.isMaybe(${value})`,
-                    sourceTypeName: `purify.Maybe<${this.resolvedType.itemType.name}>`,
-                }, {
-                    conversionExpression: (value) => `new ${this.runtimeClass.name}({ ${this.runtimeClass.stubPropertyName}: purify.Maybe.of(${this.stubType.itemType.newExpression({ parameters: value })}), resolver: async () => purify.Either.of(${value} as ${this.resolvedType.itemType.name}) })`,
-                    // Don't check instanceof value since the ObjectUnionType may be an interface
-                    // Rely on the fact that this will be the last type check on an object
-                    sourceTypeCheckExpression: (value) => `typeof ${value} === "object"`,
-                    sourceTypeName: this.resolvedType.itemType.name,
-                });
-            }
-            else if (this.resolvedType.itemType.kind === "ObjectUnionType" &&
-                this.stubType.itemType.kind === "ObjectUnionType" &&
-                this.resolvedType.itemType.memberTypes.length ===
-                    this.stubType.itemType.memberTypes.length) {
-                const maybeMap = `.map(object => { ${stubObjectUnionTypeToResolvedObjectUnionTypeSwitchStatement({ resolvedObjectUnionType: this.resolvedType.itemType, stubObjectUnionType: this.stubType.itemType, variables: { value: "object" } })} })`;
-                conversions.push({
-                    conversionExpression: (value) => `new ${this.runtimeClass.name}({ ${this.runtimeClass.stubPropertyName}: ${value}${maybeMap}, resolver: async () => purify.Either.of((${value} as purify.Maybe<${this.resolvedType.itemType.name}>).unsafeCoerce()) })`,
-                    sourceTypeCheckExpression: (value) => `purify.Maybe.isMaybe(${value})`,
-                    sourceTypeName: `purify.Maybe<${this.resolvedType.itemType.name}>`,
-                }, {
-                    conversionExpression: (value) => `new ${this.runtimeClass.name}({ ${this.runtimeClass.stubPropertyName}: purify.Maybe.of(${value})${maybeMap}, resolver: async () => purify.Either.of(${value} as ${this.resolvedType.itemType.name}) })`,
-                    // Don't check instanceof value since the ObjectUnionType may be an interface
-                    // Rely on the fact that this will be the last type check on an object
-                    sourceTypeCheckExpression: (value) => `typeof ${value} === "object"`,
-                    sourceTypeName: this.resolvedType.itemType.name,
-                });
-            }
-            conversions.push({
-                conversionExpression: () => `new ${this.runtimeClass.name}({ ${this.runtimeClass.stubPropertyName}: purify.Maybe.empty(), resolver: async () => { throw new Error("should never be called"); } })`,
-                sourceTypeCheckExpression: (value) => `typeof ${value} === "undefined"`,
-                sourceTypeName: "undefined",
-            });
-            return conversions;
-        }
-        fromRdfExpression(parameters) {
-            const { variables } = parameters;
-            return `${this.stubType.fromRdfExpression(parameters)}.map(values => values.map(${this.runtimeClass.stubPropertyName} => new ${this.runtimeClass.name}({ ${this.runtimeClass.stubPropertyName}, resolver: (identifier) => ${variables.objectSet}.${this.resolvedType.itemType.objectSetMethodNames.object}(identifier) })))`;
-        }
-        graphqlResolveExpression(parameters) {
-            return `${super.graphqlResolveExpression(parameters)}.extractNullable()`;
-        }
-    }
-    __decorate([
-        Memoize()
-    ], OptionalObjectType.prototype, "conversions", null);
-    LazyShaclProperty.OptionalObjectType = OptionalObjectType;
-    class RequiredObjectType extends SingleObjectType {
-        constructor({ resolvedType, stubType, }) {
-            super({
-                resolvedType,
-                runtimeClass: {
-                    name: `${syntheticNamePrefix}LazyRequiredObject<${resolvedType.identifierTypeAlias}, ${resolvedType.name}, ${stubType.name}>`,
-                    rawName: `${syntheticNamePrefix}LazyRequiredObject`,
-                    snippetDeclaration: SnippetDeclarations.LazyRequiredObject,
-                    stubPropertyName: "stub",
-                },
-                stubType,
-            });
-        }
-        get conversions() {
-            const conversions = super.conversions.concat();
-            if (this.stubType.kind === "ObjectType") {
-                conversions.push({
-                    conversionExpression: (value) => `new ${this.runtimeClass.name}({ ${this.runtimeClass.stubPropertyName}: ${this.stubType.newExpression({ parameters: value })}, resolver: async () => purify.Either.of(${value} as ${this.resolvedType.name}) })`,
-                    // Don't check instanceof value since the ObjectType may be an interface
-                    // Rely on the fact that this will be the last type check on an object
-                    sourceTypeCheckExpression: (value) => `typeof ${value} === "object"`,
-                    sourceTypeName: this.resolvedType.name,
-                });
-            }
-            else if (this.resolvedType.kind === "ObjectUnionType" &&
-                this.stubType.kind === "ObjectUnionType" &&
-                this.resolvedType.memberTypes.length ===
-                    this.stubType.memberTypes.length) {
-                conversions.push({
-                    conversionExpression: (value) => `new ${this.runtimeClass.name}({ ${this.runtimeClass.stubPropertyName}: ((object: ${this.resolvedType.name}) => { ${stubObjectUnionTypeToResolvedObjectUnionTypeSwitchStatement({ resolvedObjectUnionType: this.resolvedType, stubObjectUnionType: this.stubType, variables: { value: "object" } })} })(${value}), resolver: async () => purify.Either.of(${value} as ${this.resolvedType.name}) })`,
-                    // Don't check instanceof value since the ObjectUnionType may be an interface
-                    // Rely on the fact that this will be the last type check on an object
-                    sourceTypeCheckExpression: (value) => `typeof ${value} === "object"`,
-                    sourceTypeName: this.resolvedType.name,
-                });
-            }
-            return conversions;
-        }
-        fromRdfExpression(parameters) {
-            const { variables } = parameters;
-            return `${this.stubType.fromRdfExpression(parameters)}.map(values => values.map(${this.runtimeClass.stubPropertyName} => new ${this.runtimeClass.name}({ ${this.runtimeClass.stubPropertyName}, resolver: (identifier) => ${variables.objectSet}.${this.resolvedType.objectSetMethodNames.object}(identifier) })))`;
-        }
-    }
-    LazyShaclProperty.RequiredObjectType = RequiredObjectType;
-})(LazyShaclProperty || (LazyShaclProperty = {}));
-//# sourceMappingURL=LazyShaclProperty.js.map

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

@@ -1,51 +0,0 @@
-import { Maybe } from "purify-ts";
-import type { GetAccessorDeclarationStructure, OptionalKind, PropertyDeclarationStructure, PropertySignatureStructure } from "ts-morph";
-import type { Import } from "../Import.js";
-import { Property } from "./Property.js";
-export declare class TypeDiscriminatorProperty extends Property<TypeDiscriminatorProperty.Type> {
-    private readonly abstract;
-    private readonly override;
-    readonly constructorParametersPropertySignature: Maybe<OptionalKind<PropertySignatureStructure>>;
-    readonly declarationImports: readonly Import[];
-    readonly equalsFunction: Maybe<string>;
-    readonly getAccessorDeclaration: Maybe<OptionalKind<GetAccessorDeclarationStructure>>;
-    readonly graphqlField: Property<TypeDiscriminatorProperty.Type>["graphqlField"];
-    readonly initializer: string;
-    readonly mutable = false;
-    readonly recursive = false;
-    constructor({ abstract, initializer, override, type, ...superParameters }: {
-        abstract: boolean;
-        initializer: string;
-        override: boolean;
-        type: TypeDiscriminatorProperty.Type;
-    } & ConstructorParameters<typeof Property>[0]);
-    get jsonPropertySignature(): Maybe<OptionalKind<PropertySignatureStructure>>;
-    constructorStatements(): readonly string[];
-    fromJsonStatements(): readonly string[];
-    fromRdfStatements(): readonly string[];
-    hashStatements({ variables, }: Parameters<Property<TypeDiscriminatorProperty>["hashStatements"]>[0]): readonly string[];
-    jsonUiSchemaElement({ variables, }: Parameters<Property<TypeDiscriminatorProperty.Type>["jsonUiSchemaElement"]>[0]): Maybe<string>;
-    jsonZodSchema({ variables, }: Parameters<Property<TypeDiscriminatorProperty.Type>["jsonZodSchema"]>[0]): ReturnType<Property<TypeDiscriminatorProperty.Type>["jsonZodSchema"]>;
-    get propertyDeclaration(): Maybe<OptionalKind<PropertyDeclarationStructure>>;
-    get propertySignature(): Maybe<OptionalKind<PropertySignatureStructure>>;
-    snippetDeclarations(): readonly string[];
-    sparqlConstructTemplateTriples(): readonly string[];
-    sparqlWherePatterns(): readonly string[];
-    toJsonObjectMember({ variables, }: Parameters<Property<TypeDiscriminatorProperty.Type>["toJsonObjectMember"]>[0]): Maybe<string>;
-    toRdfStatements(): readonly string[];
-}
-export declare namespace TypeDiscriminatorProperty {
-    class Type {
-        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;
-        get values(): string[];
-    }
-}
-//# sourceMappingURL=TypeDiscriminatorProperty.d.ts.map

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

@@ -1,138 +0,0 @@
-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 { invariant } from "ts-invariant";
-import { Memoize } from "typescript-memoize";
-import { SnippetDeclarations } from "../SnippetDeclarations.js";
-import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
-import { Property } from "./Property.js";
-export class TypeDiscriminatorProperty extends Property {
-    abstract;
-    override;
-    constructorParametersPropertySignature = Maybe.empty();
-    declarationImports = [];
-    equalsFunction = Maybe.of(`${syntheticNamePrefix}strictEquals`);
-    getAccessorDeclaration = Maybe.empty();
-    graphqlField = Maybe.empty();
-    initializer;
-    mutable = false;
-    recursive = false;
-    constructor({ abstract, initializer, override, type, ...superParameters }) {
-        super({ ...superParameters, type });
-        invariant(this.visibility === "public");
-        this.abstract = abstract;
-        this.initializer = initializer;
-        this.override = override;
-    }
-    get jsonPropertySignature() {
-        return Maybe.of({
-            isReadonly: true,
-            name: this.name,
-            type: this.type.name,
-        });
-    }
-    constructorStatements() {
-        switch (this.objectType.declarationType) {
-            case "class":
-                return [];
-            case "interface":
-                if (this.abstract) {
-                    return [];
-                }
-                return [`const ${this.name} = "${this.initializer}" as const`];
-        }
-    }
-    fromJsonStatements() {
-        return this.fromRdfStatements();
-    }
-    fromRdfStatements() {
-        return !this.abstract && this.objectType.declarationType === "interface"
-            ? [`const ${this.name} = "${this.initializer}" as const`]
-            : [];
-    }
-    hashStatements({ variables, }) {
-        return [`${variables.hasher}.update(${variables.value});`];
-    }
-    jsonUiSchemaElement({ variables, }) {
-        const scope = `\`\${${variables.scopePrefix}}/properties/${this.name}\``;
-        return Maybe.of(`{ rule: { condition: { schema: { const: "${this.initializer}" }, scope: ${scope} }, effect: "HIDE" }, scope: ${scope}, type: "Control" }`);
-    }
-    jsonZodSchema({ variables, }) {
-        return Maybe.of({
-            key: this.name,
-            schema: this.type.values.length > 1
-                ? `${variables.zod}.enum(${JSON.stringify(this.type.values)})`
-                : `${variables.zod}.literal("${this.type.values[0]}")`,
-        });
-    }
-    get propertyDeclaration() {
-        return Maybe.of({
-            // Work around a ts-morph bug that puts the override keyword before the abstract keyword
-            isAbstract: this.abstract && this.override ? undefined : this.abstract,
-            hasOverrideKeyword: this.abstract && this.override ? undefined : this.override,
-            initializer: !this.abstract ? `"${this.initializer}"` : undefined,
-            isReadonly: true,
-            leadingTrivia: this.abstract && this.override ? "abstract override " : undefined,
-            name: this.name,
-            type: !this.abstract && this.type.name === `"${this.initializer}"`
-                ? undefined
-                : this.type.name,
-        });
-    }
-    get propertySignature() {
-        return Maybe.of({
-            isReadonly: true,
-            name: this.name,
-            type: this.type.name,
-        });
-    }
-    snippetDeclarations() {
-        const snippetDeclarations = [];
-        if (this.objectType.features.has("equals")) {
-            snippetDeclarations.push(SnippetDeclarations.strictEquals);
-        }
-        return snippetDeclarations;
-    }
-    sparqlConstructTemplateTriples() {
-        return [];
-    }
-    sparqlWherePatterns() {
-        return [];
-    }
-    toJsonObjectMember({ variables, }) {
-        return Maybe.of(`${this.name}: ${variables.value}`);
-    }
-    toRdfStatements() {
-        return [];
-    }
-}
-(function (TypeDiscriminatorProperty) {
-    class Type {
-        mutable;
-        descendantValues;
-        ownValues;
-        constructor({ descendantValues, mutable, ownValues, }) {
-            this.descendantValues = descendantValues;
-            this.mutable = mutable;
-            this.ownValues = ownValues;
-        }
-        get name() {
-            return this.values.map((name) => `"${name}"`).join(" | ");
-        }
-        get values() {
-            return this.ownValues.concat(this.descendantValues);
-        }
-    }
-    __decorate([
-        Memoize()
-    ], Type.prototype, "name", null);
-    __decorate([
-        Memoize()
-    ], Type.prototype, "values", null);
-    TypeDiscriminatorProperty.Type = Type;
-})(TypeDiscriminatorProperty || (TypeDiscriminatorProperty = {}));
-//# sourceMappingURL=TypeDiscriminatorProperty.js.map

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

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

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

@@ -1,122 +0,0 @@
-import { Maybe } from "purify-ts";
-import { StructureKind, } from "ts-morph";
-import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
-import { tsComment } from "../tsComment.js";
-import { equalsFunctionOrMethodDeclaration } from "./equalsFunctionOrMethodDeclaration.js";
-import { hashFunctionOrMethodDeclarations } from "./hashFunctionOrMethodDeclarations.js";
-import { toJsonFunctionOrMethodDeclaration } from "./toJsonFunctionOrMethodDeclaration.js";
-import { toRdfFunctionOrMethodDeclaration } from "./toRdfFunctionOrMethodDeclaration.js";
-function constructorDeclaration() {
-    const parametersPropertySignatures = this.properties.flatMap((property) => property.constructorParametersPropertySignature.toList());
-    const parametersType = [];
-    if (parametersPropertySignatures.length > 0) {
-        parametersType.push(`{ ${parametersPropertySignatures
-            .map((propertySignature) => `readonly ${propertySignature.name}${propertySignature.hasQuestionToken ? "?" : ""}: ${propertySignature.type}`)
-            .join(", ")} }`);
-    }
-    if (this.parentObjectTypes.length > 0) {
-        // Pass up parameters
-        parametersType.push(`ConstructorParameters<typeof ${this.parentObjectTypes[0].name}>[0]`);
-    }
-    if (parametersType.length === 0) {
-        parametersType.push("object");
-    }
-    const statements = [];
-    if (this.parentObjectTypes.length > 0) {
-        // An ancestor object type may be extern so we always have a constructor and always pass up parameters instead
-        // of trying to sense whether we need to or not.
-        statements.push("super(parameters);");
-    }
-    const parametersHasQuestionToken = this.parentObjectTypes.length === 0 &&
-        parametersPropertySignatures.every((propertySignature) => !!propertySignature.hasQuestionToken);
-    const parametersVariable = `parameters${parametersHasQuestionToken ? "?" : ""}`;
-    const propertyStatements = this.properties.flatMap((property) => property.constructorStatements({
-        variables: {
-            parameter: `${parametersVariable}.${property.name}`,
-            parameters: parametersVariable,
-        },
-    }));
-    statements.push(...propertyStatements);
-    return {
-        leadingTrivia: propertyStatements.length === 0
-            ? "// biome-ignore lint/complexity/noUselessConstructor: Always have a constructor\n"
-            : undefined,
-        parameters: [
-            {
-                hasQuestionToken: parametersHasQuestionToken,
-                name: statements.length > 0 ? "parameters" : "_parameters",
-                type: parametersType.join(" & "),
-            },
-        ],
-        statements,
-    };
-}
-export function classDeclaration() {
-    if (this.declarationType !== "class") {
-        return Maybe.empty();
-    }
-    if (this.extern) {
-        return Maybe.empty();
-    }
-    this.ensureAtMostOneSuperObjectType();
-    const getAccessors = [];
-    const properties = [];
-    for (const property of this.properties) {
-        property.propertyDeclaration.ifJust((propertyDeclaration) => properties.push(propertyDeclaration));
-        property.getAccessorDeclaration.ifJust((getAccessor) => getAccessors.push(getAccessor));
-    }
-    return Maybe.of({
-        ctors: [constructorDeclaration.bind(this)()],
-        extends: this.parentObjectTypes.length > 0
-            ? this.parentObjectTypes[0].name
-            : undefined,
-        getAccessors,
-        isAbstract: this.abstract,
-        isExported: this.export,
-        kind: StructureKind.Class,
-        leadingTrivia: this.comment.alt(this.label).map(tsComment).extract(),
-        methods: [
-            ...equalsMethodDeclaration.bind(this)().toList(),
-            ...hashMethodDeclarations.bind(this)(),
-            ...toJsonMethodDeclaration.bind(this)().toList(),
-            ...toRdfMethodDeclaration.bind(this)().toList(),
-            ...toStringMethodDeclaration.bind(this)().toList(),
-        ],
-        name: this.name,
-        properties,
-    });
-}
-function equalsMethodDeclaration() {
-    return equalsFunctionOrMethodDeclaration.bind(this)();
-}
-function hashMethodDeclarations() {
-    return hashFunctionOrMethodDeclarations.bind(this)();
-}
-function toJsonMethodDeclaration() {
-    return toJsonFunctionOrMethodDeclaration
-        .bind(this)()
-        .map((toJsonFunctionOrMethodDeclaration) => ({
-        ...toJsonFunctionOrMethodDeclaration,
-        hasOverrideKeyword: this.parentObjectTypes.length > 0,
-    }));
-}
-function toRdfMethodDeclaration() {
-    return toRdfFunctionOrMethodDeclaration
-        .bind(this)()
-        .map((toRdfFunctionOrMethodDeclaration) => ({
-        ...toRdfFunctionOrMethodDeclaration,
-        hasOverrideKeyword: this.parentObjectTypes.length > 0,
-    }));
-}
-function toStringMethodDeclaration() {
-    if (!this.features.has("json")) {
-        return Maybe.empty();
-    }
-    return Maybe.of({
-        hasOverrideKeyword: this.parentObjectTypes.length > 0,
-        name: "toString",
-        returnType: "string",
-        statements: [`return JSON.stringify(this.${syntheticNamePrefix}toJson());`],
-    });
-}
-//# sourceMappingURL=classDeclaration.js.map

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

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