@shaclmate/compiler 4.0.24 → 4.0.25

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

@@ -1,52 +0,0 @@
-import { Maybe } from "purify-ts";
-import { snippets } from "../snippets.js";
-import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
-import { code, joinCode } from "../ts-poet-wrapper.js";
-export function NamedObjectType_equalsFunctionOrMethodDeclaration() {
-    if (!this.features.has("equals")) {
-        return Maybe.empty();
-    }
-    const chain = [];
-    let leftVariable;
-    let parameters;
-    let preamble;
-    let rightVariable;
-    switch (this.declarationType) {
-        case "class":
-            if (this.properties.length === 0) {
-                // If there's a parent class and no properties in this class, can skip overriding equals
-                return Maybe.empty();
-            }
-            leftVariable = code `this`;
-            parameters = code `other: ${this.name}`;
-            if (this.parentObjectTypes.length > 0) {
-                chain.push(code `super.${syntheticNamePrefix}equals(other)`);
-                preamble = "override ";
-            }
-            else {
-                preamble = "";
-            }
-            rightVariable = code `other`;
-            break;
-        case "interface":
-            // For every parent, find the nearest equals implementation
-            for (const parentObjectType of this.parentObjectTypes) {
-                chain.push(code `${parentObjectType.staticModuleName}.${syntheticNamePrefix}equals(left, right)`);
-            }
-            leftVariable = code `left`;
-            parameters = code `left: ${this.name}, right: ${this.name}`;
-            preamble = "export function ";
-            rightVariable = code `right`;
-    }
-    for (const property of this.properties) {
-        if (property.kind === "DiscriminantProperty") {
-            continue;
-        }
-        chain.push(code `(${property.type.equalsFunction})(${property.accessExpression({ variables: { object: leftVariable } })}, ${property.accessExpression({ variables: { object: rightVariable } })}).mapLeft(propertyValuesUnequal => ({ left: ${leftVariable}, right: ${rightVariable}, propertyName: "${property.name}", propertyValuesUnequal, type: "property" as const }))`);
-    }
-    return Maybe.of(code `\
-${preamble}${syntheticNamePrefix}equals(${parameters}): ${snippets.EqualsResult} {
-  return ${joinCode(chain.map((chainPart, chainPartI) => chainPartI === 0 ? chainPart : code `chain(() => ${chainPart})`), { on: "." })}
-}`);
-}
-//# sourceMappingURL=NamedObjectType_equalsFunctionOrMethodDeclaration.js.map

package/dist/generators/ts/_NamedObjectType/NamedObjectType_hashFunctionOrMethodDeclarations.d.ts

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

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

@@ -1,77 +0,0 @@
-import { snippets } from "../snippets.js";
-import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
-import { code, joinCode } from "../ts-poet-wrapper.js";
-const hasherVariable = code `_hasher`;
-export function NamedObjectType_hashFunctionOrMethodDeclarations() {
-    if (!this.features.has("hash")) {
-        return [];
-    }
-    const hashOwnShaclPropertiesStatements = this.properties.flatMap((property) => property.kind === "ShaclProperty"
-        ? property.hashStatements({
-            depth: 0,
-            variables: {
-                hasher: hasherVariable,
-                value: property.accessExpression({
-                    variables: { object: this.thisVariable },
-                }),
-            },
-        })
-        : []);
-    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 hashShaclPropertiesStatements = [];
-    const hashStatements = [];
-    const parameters = []; // Same between the two functions
-    let hashPreamble = "";
-    let hashShaclPropertiesPreamble = "";
-    switch (this.declarationType) {
-        case "class": {
-            if (this.parentObjectTypes.length > 0) {
-                hashShaclPropertiesStatements.push(code `super.${syntheticNamePrefix}hashShaclProperties(${hasherVariable});`);
-                hashShaclPropertiesPreamble = "override ";
-                hashPreamble = "override ";
-            }
-            hashShaclPropertiesPreamble = `protected ${hashShaclPropertiesPreamble}`;
-            hashStatements.push(code `this.${syntheticNamePrefix}hashShaclProperties(${hasherVariable});`);
-            break;
-        }
-        case "interface": {
-            for (const parentObjectType of this.parentObjectTypes) {
-                hashShaclPropertiesStatements.push(code `${parentObjectType.staticModuleName}.${syntheticNamePrefix}hashShaclProperties(${this.thisVariable}, ${hasherVariable});`);
-            }
-            parameters.push(code `${this.thisVariable}: ${this.name}`);
-            hashPreamble = hashShaclPropertiesPreamble = "export function ";
-            hashStatements.push(code `${this.staticModuleName}.${syntheticNamePrefix}hashShaclProperties(${this.thisVariable}, ${hasherVariable});`);
-            break;
-        }
-    }
-    parameters.push(code `${hasherVariable}: HasherT`);
-    const parametersCode = joinCode(parameters, { on: "," });
-    hashShaclPropertiesStatements.push(...hashOwnShaclPropertiesStatements);
-    hashShaclPropertiesStatements.push(code `return ${hasherVariable};`);
-    hashStatements.push(...this.properties
-        .filter((property) => property.kind !== "ShaclProperty")
-        .flatMap((property) => property.hashStatements({
-        depth: 0,
-        variables: {
-            hasher: hasherVariable,
-            value: code `${property.accessExpression({ variables: { object: this.thisVariable } })}`,
-        },
-    })));
-    hashStatements.push(code `return ${hasherVariable};`);
-    return [
-        code `\
-${hashPreamble}${syntheticNamePrefix}hash<HasherT extends ${snippets.Hasher}>(${parametersCode}): HasherT {
-  ${joinCode(hashStatements)}
-}`,
-        code `\
-${hashShaclPropertiesPreamble}${syntheticNamePrefix}hashShaclProperties<HasherT extends ${snippets.Hasher}>(${parametersCode}): HasherT {
-  ${joinCode(hashShaclPropertiesStatements)}
-}`,
-    ];
-}
-//# sourceMappingURL=NamedObjectType_hashFunctionOrMethodDeclarations.js.map

package/dist/generators/ts/_NamedObjectType/NamedObjectType_toJsonFunctionOrMethodDeclaration.d.ts

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

package/dist/generators/ts/_NamedObjectType/NamedObjectType_toRdfResourceFunctionOrMethodDeclaration.d.ts

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

package/dist/generators/ts/_NamedObjectType/NamedObjectType_toStringFunctionOrMethodDeclaration.d.ts

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

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

@@ -1,66 +0,0 @@
-import { snippets } from "../snippets.js";
-import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
-import { code, joinCode, literalOf } from "../ts-poet-wrapper.js";
-export function NamedObjectType_toStringFunctionOrMethodDeclarations() {
-    const propertiesToStringRecordProperties = [];
-    if (this.parentObjectTypes.length > 0) {
-        switch (this.declarationType) {
-            case "class": {
-                propertiesToStringRecordProperties.push(code `...super.${syntheticNamePrefix}propertiesToStrings()`);
-                break;
-            }
-            case "interface": {
-                for (const parentObjectType of this.parentObjectTypes) {
-                    propertiesToStringRecordProperties.push(code `...${parentObjectType.staticModuleName}.${syntheticNamePrefix}propertiesToStrings(${this.thisVariable})`);
-                }
-                break;
-            }
-        }
-    }
-    for (const property of this.properties) {
-        property
-            .toStringExpression({
-            variables: {
-                value: property.accessExpression({
-                    variables: { object: this.thisVariable },
-                }),
-            },
-        })
-            .ifJust((propertyToStringExpression) => {
-            propertiesToStringRecordProperties.push(code `${literalOf(property.name)}: ${propertyToStringExpression}`);
-        });
-    }
-    const propertiesToStringsReturnExpression = code `${snippets.compactRecord}({${joinCode(propertiesToStringRecordProperties, { on: "," })}})`;
-    const toStringReturnExpression = (propertiesToStrings) => code `\`${this.name}(\${JSON.stringify(${propertiesToStrings})})\``;
-    switch (this.declarationType) {
-        case "class": {
-            let propertiesToStringsPreamble = "";
-            let toStringPreamble = "";
-            if (this.parentObjectTypes.length > 0) {
-                propertiesToStringsPreamble = "override ";
-                toStringPreamble = "override ";
-            }
-            propertiesToStringsPreamble = `protected ${propertiesToStringsPreamble}`;
-            return [
-                code `${propertiesToStringsPreamble}${syntheticNamePrefix}propertiesToStrings(): Record<string, string> { return ${propertiesToStringsReturnExpression}; }`,
-                code `${toStringPreamble}toString(): string { return ${toStringReturnExpression(code `this.${syntheticNamePrefix}propertiesToStrings()`)}; }`,
-            ];
-        }
-        case "interface": {
-            return [
-                // Use overloads to allow the function to be attached to an instance or used freestanding
-                code `\
-export function ${syntheticNamePrefix}propertiesToStrings(${this.thisVariable}: ${this.name}): Record<string, string> {
-  return ${propertiesToStringsReturnExpression};
-}`,
-                code `\
-export function ${syntheticNamePrefix}toString(this: ${this.name}): string;
-export function ${syntheticNamePrefix}toString(${this.thisVariable}: ${this.name}): string;
-export function ${syntheticNamePrefix}toString(this: ${this.name} | undefined, ${this.thisVariable}?: ${this.name}): string {
-  return ${toStringReturnExpression(code `${syntheticNamePrefix}propertiesToStrings((${this.thisVariable} ?? this)!)`)};
-}`,
-            ];
-        }
-    }
-}
-//# sourceMappingURL=NamedObjectType_toStringFunctionOrMethodDeclaration.js.map