@shaclmate/compiler 3.0.4 → 4.0.0

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

@@ -1,73 +0,0 @@
-import { Maybe } from "purify-ts";
-import { invariant } from "ts-invariant";
-import { StructureKind } from "ts-morph";
-import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
-export function createFunctionDeclaration() {
-    if (!this.features.has("create")) {
-        return Maybe.empty();
-    }
-    if (this.declarationType !== "interface") {
-        return Maybe.empty();
-    }
-    if (this.extern) {
-        return Maybe.empty();
-    }
-    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(", ")} }`);
-    }
-    for (const parentObjectType of this.parentObjectTypes) {
-        parametersType.push(`Parameters<typeof ${parentObjectType.staticModuleName}.${syntheticNamePrefix}create>[0]`);
-    }
-    if (parametersType.length === 0) {
-        parametersType.push("object");
-    }
-    const propertyInitializers = [];
-    const omitPropertyNames = [];
-    const propertyStatements = [];
-    for (const parentObjectType of this.parentObjectTypes) {
-        propertyInitializers.push(`...${parentObjectType.staticModuleName}.${syntheticNamePrefix}create(parameters)`);
-    }
-    const parametersHasQuestionToken = this.parentObjectTypes.length === 0 &&
-        parametersPropertySignatures.every((propertySignature) => !!propertySignature.hasQuestionToken);
-    const parametersVariable = `parameters${parametersHasQuestionToken ? "?" : ""}`;
-    for (const property of this.properties) {
-        const thisPropertyStatements = property.constructorStatements({
-            variables: {
-                parameter: `${parametersVariable}.${property.name}`,
-                parameters: parametersVariable,
-            },
-        });
-        if (thisPropertyStatements.length > 0) {
-            propertyInitializers.push(property.name);
-            propertyStatements.push(...thisPropertyStatements);
-        }
-        else {
-            omitPropertyNames.push(property.name);
-        }
-    }
-    invariant(propertyInitializers.length > 0);
-    invariant(propertyStatements.length > 0);
-    return Maybe.of({
-        isExported: true,
-        kind: StructureKind.Function,
-        name: `${syntheticNamePrefix}create`,
-        parameters: [
-            {
-                hasQuestionToken: parametersHasQuestionToken,
-                name: "parameters",
-                type: parametersType.join(" & "),
-            },
-        ],
-        returnType: omitPropertyNames.length === 0
-            ? this.name
-            : `Omit<${this.name}, ${omitPropertyNames.map((omitPropertyName) => `"${omitPropertyName}"`).join(" | ")}>`,
-        statements: propertyStatements.concat([
-            `return { ${propertyInitializers.join(", ")} }`,
-        ]),
-    });
-}
-//# sourceMappingURL=createFunctionDeclaration.js.map

package/dist/generators/ts/_ObjectType/equalsFunctionDeclaration.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 equalsFunctionDeclaration(this: ObjectType): Maybe<FunctionDeclarationStructure>;
-//# sourceMappingURL=equalsFunctionDeclaration.d.ts.map

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

@@ -1,19 +0,0 @@
-import { Maybe } from "purify-ts";
-import { StructureKind } from "ts-morph";
-import { equalsFunctionOrMethodDeclaration } from "./equalsFunctionOrMethodDeclaration.js";
-export function equalsFunctionDeclaration() {
-    if (this.declarationType !== "interface") {
-        return Maybe.empty();
-    }
-    if (this.extern) {
-        return Maybe.empty();
-    }
-    return equalsFunctionOrMethodDeclaration
-        .bind(this)()
-        .map((equalsFunctionOrMethodDeclaration) => ({
-        ...equalsFunctionOrMethodDeclaration,
-        isExported: true,
-        kind: StructureKind.Function,
-    }));
-}
-//# sourceMappingURL=equalsFunctionDeclaration.js.map

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

@@ -1,11 +0,0 @@
-import { Maybe } from "purify-ts";
-import type { OptionalKind, ParameterDeclarationStructure } from "ts-morph";
-import type { ObjectType } from "../ObjectType.js";
-export declare function equalsFunctionOrMethodDeclaration(this: ObjectType): Maybe<{
-    hasOverrideKeyword: boolean;
-    name: string;
-    parameters: OptionalKind<ParameterDeclarationStructure>[];
-    returnType: string;
-    statements: string[];
-}>;
-//# sourceMappingURL=equalsFunctionOrMethodDeclaration.d.ts.map

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

@@ -1,73 +0,0 @@
-import { Maybe } from "purify-ts";
-import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
-export function equalsFunctionOrMethodDeclaration() {
-    if (!this.features.has("equals")) {
-        return Maybe.empty();
-    }
-    if (this.declarationType === "class" && this.ownProperties.length === 0) {
-        // If there's a parent class and no properties in this class, can skip overriding equals
-        return Maybe.empty();
-    }
-    let leftVariable;
-    let rightVariable;
-    switch (this.declarationType) {
-        case "class":
-            leftVariable = "this";
-            rightVariable = "other";
-            break;
-        case "interface":
-            leftVariable = "left";
-            rightVariable = "right";
-    }
-    const chain = [];
-    let hasOverrideKeyword = false;
-    if (this.parentObjectTypes.length > 0) {
-        switch (this.declarationType) {
-            case "class": {
-                chain.push(`super.${syntheticNamePrefix}equals(other)`);
-                hasOverrideKeyword = true;
-                break;
-            }
-            case "interface": {
-                // For every parent, find the nearest equals implementation
-                for (const parentObjectType of this.parentObjectTypes) {
-                    chain.push(`${parentObjectType.staticModuleName}.${syntheticNamePrefix}equals(left, right)`);
-                }
-                break;
-            }
-        }
-    }
-    for (const property of this.ownProperties) {
-        property.equalsFunction.ifJust((equalsFunction) => {
-            chain.push(`(${equalsFunction})(${leftVariable}.${property.name}, ${rightVariable}.${property.name}).mapLeft(propertyValuesUnequal => ({ left: ${leftVariable}, right: ${rightVariable}, propertyName: "${property.name}", propertyValuesUnequal, type: "Property" as const }))`);
-        });
-    }
-    return Maybe.of({
-        hasOverrideKeyword,
-        name: `${syntheticNamePrefix}equals`,
-        parameters: this.declarationType === "interface"
-            ? [
-                {
-                    name: "left",
-                    type: this.name,
-                },
-                {
-                    name: "right",
-                    type: this.name,
-                },
-            ]
-            : [
-                {
-                    name: "other",
-                    type: this.name,
-                },
-            ],
-        returnType: `${syntheticNamePrefix}EqualsResult`,
-        statements: [
-            `return ${chain
-                .map((chainPart, chainPartI) => chainPartI === 0 ? chainPart : `chain(() => ${chainPart})`)
-                .join(".")};`,
-        ],
-    });
-}
-//# sourceMappingURL=equalsFunctionOrMethodDeclaration.js.map

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

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

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

@@ -1,28 +0,0 @@
-import { Maybe } from "purify-ts";
-import { StructureKind, VariableDeclarationKind, } from "ts-morph";
-import { rdfjsTermExpression } from "../rdfjsTermExpression.js";
-import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
-export function fromRdfTypeVariableStatement() {
-    if (!this.features.has("rdf")) {
-        return Maybe.empty();
-    }
-    if (this.extern) {
-        return Maybe.empty();
-    }
-    if (this.fromRdfType.isNothing()) {
-        return Maybe.empty();
-    }
-    return Maybe.of({
-        declarationKind: VariableDeclarationKind.Const,
-        kind: StructureKind.VariableStatement,
-        declarations: [
-            {
-                name: `${syntheticNamePrefix}fromRdfType`,
-                initializer: rdfjsTermExpression(this.fromRdfType.unsafeCoerce()),
-                type: "rdfjs.NamedNode<string>",
-            },
-        ],
-        isExported: true,
-    });
-}
-//# sourceMappingURL=fromRdfTypeVariableStatement.js.map

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

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

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

@@ -1,49 +0,0 @@
-import { StructureKind, VariableDeclarationKind, } from "ts-morph";
-import { Maybe } from "purify-ts";
-import { objectInitializer } from "../objectInitializer.js";
-import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
-export function graphqlTypeVariableStatement() {
-    if (!this.features.has("graphql")) {
-        return Maybe.empty();
-    }
-    if (this.extern) {
-        return Maybe.empty();
-    }
-    if (this.synthetic) {
-        return Maybe.empty();
-    }
-    return Maybe.of({
-        declarationKind: VariableDeclarationKind.Const,
-        kind: StructureKind.VariableStatement,
-        declarations: [
-            {
-                name: `${syntheticNamePrefix}GraphQL`,
-                initializer: `new graphql.GraphQLObjectType<${this.name}, { objectSet: ${syntheticNamePrefix}ObjectSet }>(${objectInitializer({
-                    description: this.comment.map(JSON.stringify).extract(),
-                    fields: `() => (${objectInitializer(this.properties.reduce((fields, property) => {
-                        property.graphqlField.ifJust((field) => {
-                            fields[field.name] = objectInitializer({
-                                args: field.args
-                                    .map((args) => objectInitializer(Object.entries(args).reduce((argObjects, [argName, arg]) => {
-                                    argObjects[argName] = objectInitializer(arg);
-                                    return argObjects;
-                                }, {})))
-                                    .extract(),
-                                description: field.description
-                                    .map(JSON.stringify)
-                                    .extract(),
-                                name: JSON.stringify(field.name),
-                                resolve: field.resolve,
-                                type: field.type,
-                            });
-                        });
-                        return fields;
-                    }, {}))})`,
-                    name: `"${this.name}"`,
-                })})`,
-            },
-        ],
-        isExported: true,
-    });
-}
-//# sourceMappingURL=graphqlTypeVariableStatement.js.map

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

@@ -1,4 +0,0 @@
-import { type FunctionDeclarationStructure } from "ts-morph";
-import type { ObjectType } from "../ObjectType.js";
-export declare function hashFunctionDeclarations(this: ObjectType): readonly FunctionDeclarationStructure[];
-//# sourceMappingURL=hashFunctionDeclarations.d.ts.map

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

@@ -1,18 +0,0 @@
-import { StructureKind } from "ts-morph";
-import { hashFunctionOrMethodDeclarations } from "./hashFunctionOrMethodDeclarations.js";
-export function hashFunctionDeclarations() {
-    if (this.declarationType !== "interface") {
-        return [];
-    }
-    if (this.extern) {
-        return [];
-    }
-    return hashFunctionOrMethodDeclarations
-        .bind(this)()
-        .map((hashFunctionOrMethodDeclaration) => ({
-        ...hashFunctionOrMethodDeclaration,
-        isExported: true,
-        kind: StructureKind.Function,
-    }));
-}
-//# sourceMappingURL=hashFunctionDeclarations.js.map

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

@@ -1,13 +0,0 @@
-import { type OptionalKind, type ParameterDeclarationStructure, Scope, type TypeParameterDeclarationStructure } from "ts-morph";
-import { ObjectType } from "../ObjectType.js";
-export declare const hasherTypeConstraint = "{ update: (message: string | number[] | ArrayBuffer | Uint8Array) => void; }";
-export declare function hashFunctionOrMethodDeclarations(this: ObjectType): readonly {
-    hasOverrideKeyword?: boolean;
-    name: string;
-    parameters: OptionalKind<ParameterDeclarationStructure>[];
-    returnType: string;
-    scope?: Scope;
-    statements: string[];
-    typeParameters: OptionalKind<TypeParameterDeclarationStructure>[];
-}[];
-//# sourceMappingURL=hashFunctionOrMethodDeclarations.d.ts.map

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

@@ -1,96 +0,0 @@
-import { Scope, } from "ts-morph";
-import { ObjectType } from "../ObjectType.js";
-import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
-const hasherVariable = "_hasher";
-export const hasherTypeConstraint = "{ update: (message: string | number[] | ArrayBuffer | Uint8Array) => void; }";
-export function hashFunctionOrMethodDeclarations() {
-    if (!this.features.has("hash")) {
-        return [];
-    }
-    const hashOwnShaclPropertiesStatements = this.ownShaclProperties.flatMap((property) => property.hashStatements({
-        depth: 0,
-        variables: {
-            hasher: hasherVariable,
-            value: `${this.thisVariable}.${property.name}`,
-        },
-    }));
-    if (this.declarationType === "class" &&
-        this.parentObjectTypes.length > 0 &&
-        hashOwnShaclPropertiesStatements.length === 0) {
-        // If there's a parent class and no hash statements in this class, can skip overriding hash
-        return [];
-    }
-    const parameters = [];
-    if (this.declarationType === "interface") {
-        parameters.push({
-            name: this.thisVariable,
-            type: this.name,
-        });
-    }
-    parameters.push({
-        name: hasherVariable,
-        type: "HasherT",
-    });
-    const hashShaclPropertiesStatements = [];
-    let hasOverrideKeyword = false;
-    if (this.parentObjectTypes.length > 0) {
-        switch (this.declarationType) {
-            case "class": {
-                hashShaclPropertiesStatements.push(`super.${syntheticNamePrefix}hashShaclProperties(${hasherVariable});`);
-                hasOverrideKeyword = true;
-                break;
-            }
-            case "interface": {
-                for (const parentObjectType of this.parentObjectTypes) {
-                    hashShaclPropertiesStatements.push(`${parentObjectType.staticModuleName}.${syntheticNamePrefix}hashShaclProperties(${this.thisVariable}, ${hasherVariable});`);
-                }
-                break;
-            }
-        }
-    }
-    hashShaclPropertiesStatements.push(...hashOwnShaclPropertiesStatements);
-    const returnType = "HasherT";
-    const typeParameters = [
-        {
-            name: "HasherT",
-            constraint: hasherTypeConstraint,
-        },
-    ];
-    return [
-        {
-            hasOverrideKeyword,
-            name: `${syntheticNamePrefix}hash`,
-            parameters,
-            returnType,
-            statements: [
-                ...this.ownProperties
-                    .filter((property) => !(property instanceof ObjectType.ShaclProperty))
-                    .flatMap((property) => property.hashStatements({
-                    depth: 0,
-                    variables: {
-                        hasher: hasherVariable,
-                        value: `${this.thisVariable}.${property.name}`,
-                    },
-                })),
-                this.declarationType === "class"
-                    ? `this.${syntheticNamePrefix}hashShaclProperties(${hasherVariable});`
-                    : `${this.staticModuleName}.${syntheticNamePrefix}hashShaclProperties(${this.thisVariable}, ${hasherVariable});`,
-                `return ${hasherVariable};`,
-            ],
-            typeParameters,
-        },
-        {
-            hasOverrideKeyword,
-            name: `${syntheticNamePrefix}hashShaclProperties`,
-            parameters,
-            returnType,
-            scope: this.declarationType === "class" ? Scope.Protected : undefined,
-            statements: [
-                ...hashShaclPropertiesStatements,
-                `return ${hasherVariable};`,
-            ],
-            typeParameters,
-        },
-    ];
-}
-//# sourceMappingURL=hashFunctionOrMethodDeclarations.js.map

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

@@ -1,22 +0,0 @@
-export * from "./classDeclaration.js";
-export * from "./createFunctionDeclaration.js";
-export * from "./EagerShaclProperty.js";
-export * from "./equalsFunctionDeclaration.js";
-export * from "./fromRdfTypeVariableStatement.js";
-export * from "./graphqlTypeVariableStatement.js";
-export * from "./hashFunctionDeclarations.js";
-export * from "./identifierTypeDeclarations.js";
-export * from "./IdentifierPrefixProperty.js";
-export * from "./IdentifierProperty.js";
-export * from "./interfaceDeclaration.js";
-export * from "./jsonFunctionDeclarations.js";
-export * from "./jsonTypeAliasDeclaration.js";
-export * from "./LazyShaclProperty.js";
-export * from "./objectSetMethodNames.js";
-export * from "./propertiesVariableStatement.js";
-export * from "./Property.js";
-export * from "./rdfFunctionDeclarations.js";
-export * from "./ShaclProperty.js";
-export * from "./sparqlFunctionDeclarations.js";
-export * from "./TypeDiscriminatorProperty.js";
-//# sourceMappingURL=index.d.ts.map

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

@@ -1,22 +0,0 @@
-export * from "./classDeclaration.js";
-export * from "./createFunctionDeclaration.js";
-export * from "./EagerShaclProperty.js";
-export * from "./equalsFunctionDeclaration.js";
-export * from "./fromRdfTypeVariableStatement.js";
-export * from "./graphqlTypeVariableStatement.js";
-export * from "./hashFunctionDeclarations.js";
-export * from "./identifierTypeDeclarations.js";
-export * from "./IdentifierPrefixProperty.js";
-export * from "./IdentifierProperty.js";
-export * from "./interfaceDeclaration.js";
-export * from "./jsonFunctionDeclarations.js";
-export * from "./jsonTypeAliasDeclaration.js";
-export * from "./LazyShaclProperty.js";
-export * from "./objectSetMethodNames.js";
-export * from "./propertiesVariableStatement.js";
-export * from "./Property.js";
-export * from "./rdfFunctionDeclarations.js";
-export * from "./ShaclProperty.js";
-export * from "./sparqlFunctionDeclarations.js";
-export * from "./TypeDiscriminatorProperty.js";
-//# sourceMappingURL=index.js.map

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

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

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

@@ -1,21 +0,0 @@
-import { Maybe } from "purify-ts";
-import { StructureKind, } from "ts-morph";
-import { tsComment } from "../tsComment.js";
-export function interfaceDeclaration() {
-    if (this.declarationType !== "interface") {
-        return Maybe.empty();
-    }
-    if (this.extern) {
-        return Maybe.empty();
-    }
-    const properties = this.properties.flatMap((property) => property.propertySignature.toList());
-    return Maybe.of({
-        extends: this.parentObjectTypes.map((parentObjectType) => parentObjectType.name),
-        isExported: true,
-        kind: StructureKind.Interface,
-        leadingTrivia: this.comment.alt(this.label).map(tsComment).extract(),
-        name: this.name,
-        properties,
-    });
-}
-//# sourceMappingURL=interfaceDeclaration.js.map

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

@@ -1,4 +0,0 @@
-import { type FunctionDeclarationStructure } from "ts-morph";
-import type { ObjectType } from "../ObjectType.js";
-export declare function jsonFunctionDeclarations(this: ObjectType): readonly FunctionDeclarationStructure[];
-//# sourceMappingURL=jsonFunctionDeclarations.d.ts.map