@shaclmate/compiler 4.0.23 → 4.0.25

package/package.json

@@ -1,6 +1,6 @@
 {
   "dependencies": {
-    "@shaclmate/shacl-ast": "4.0.23",
+    "@shaclmate/shacl-ast": "4.0.25",
     "@rdfjs/dataset": "~2.0.2",
     "@rdfjs/prefix-map": "~0.1.2",
     "@rdfjs/term-map": "~2.0.2",
@@ -37,8 +37,6 @@
     "dist/_ShapesGraphToAstTransformer/*.js",
     "dist/ast/*.d.ts",
     "dist/ast/*.js",
-    "dist/enums/*.d.ts",
-    "dist/enums/*.js",
     "dist/generators/*.d.ts",
     "dist/generators/*.js",
     "dist/generators/ts/*.d.ts",
@@ -70,5 +68,5 @@
   },
   "type": "module",
   "types": "./dist/index.d.ts",
-  "version": "4.0.23"
+  "version": "4.0.25"
 }

package/dist/_ShapesGraphToAstTransformer/nodeShapeIdentifierMintingStrategy.d.ts

@@ -1,6 +0,0 @@
-import { Either, Maybe } from "purify-ts";
-import { IdentifierMintingStrategy } from "../enums/IdentifierMintingStrategy.js";
-import type * as input from "../input/index.js";
-import type { ShapesGraphToAstTransformer } from "../ShapesGraphToAstTransformer.js";
-export declare function nodeShapeIdentifierMintingStrategy(this: ShapesGraphToAstTransformer, nodeShape: input.NodeShape): Either<Error, Maybe<IdentifierMintingStrategy>>;
-//# sourceMappingURL=nodeShapeIdentifierMintingStrategy.d.ts.map

package/dist/_ShapesGraphToAstTransformer/nodeShapeIdentifierMintingStrategy.js

@@ -1,32 +0,0 @@
-import { Either, Left, Maybe } from "purify-ts";
-import { IdentifierMintingStrategy } from "../enums/IdentifierMintingStrategy.js";
-import { shapeNodeKinds } from "./shapeNodeKinds.js";
-const defaultNodeShapeNodeKinds = new Set([
-    "BlankNode",
-    "IRI",
-]);
-export function nodeShapeIdentifierMintingStrategy(nodeShape) {
-    if (nodeShape.identifierMintingStrategy.isJust()) {
-        if (nodeShape.in_.filter((_) => _.length > 0).isJust()) {
-            return Left(new Error(`${nodeShape} cannot have an identifier minting strategy and sh:in`));
-        }
-        return Either.of(nodeShape.identifierMintingStrategy.map(IdentifierMintingStrategy.fromIri));
-    }
-    // Recurse into parents
-    for (const parentNodeShape of this.relatedNodeShapesByIdentifier.get(nodeShape.$identifier).parents) {
-        const parentNodeShapeIdentifierMintingStrategy = nodeShapeIdentifierMintingStrategy.call(this, parentNodeShape);
-        if (parentNodeShapeIdentifierMintingStrategy.isRight() &&
-            parentNodeShapeIdentifierMintingStrategy.extract().isJust()) {
-            return parentNodeShapeIdentifierMintingStrategy;
-        }
-    }
-    return shapeNodeKinds
-        .call(this, nodeShape, { defaultNodeShapeNodeKinds })
-        .map((nodeKinds) => {
-        if (nodeKinds.has("BlankNode")) {
-            return Maybe.of("blankNode");
-        }
-        return Maybe.empty();
-    });
-}
-//# sourceMappingURL=nodeShapeIdentifierMintingStrategy.js.map

package/dist/enums/IdentifierMintingStrategy.d.ts

@@ -1,9 +0,0 @@
-import type { NamedNode } from "@rdfjs/types";
-/**
- * TypeScript enum corresponding to shaclmate:identifierMintingStrategy, for simpler manipulation.
- */
-export type IdentifierMintingStrategy = "blankNode" | "sha256" | "uuidv4";
-export declare namespace IdentifierMintingStrategy {
-    function fromIri(iri: NamedNode<"http://purl.org/shaclmate/ontology#_IdentifierMintingStrategy_BlankNode" | "http://purl.org/shaclmate/ontology#_IdentifierMintingStrategy_SHA256" | "http://purl.org/shaclmate/ontology#_IdentifierMintingStrategy_UUIDv4">): IdentifierMintingStrategy;
-}
-//# sourceMappingURL=IdentifierMintingStrategy.d.ts.map

package/dist/enums/IdentifierMintingStrategy.js

@@ -1,18 +0,0 @@
-export var IdentifierMintingStrategy;
-(function (IdentifierMintingStrategy) {
-    function fromIri(iri) {
-        switch (iri.value) {
-            case "http://purl.org/shaclmate/ontology#_IdentifierMintingStrategy_BlankNode":
-                return "blankNode";
-            case "http://purl.org/shaclmate/ontology#_IdentifierMintingStrategy_SHA256":
-                return "sha256";
-            case "http://purl.org/shaclmate/ontology#_IdentifierMintingStrategy_UUIDv4":
-                return "uuidv4";
-            default:
-                iri.value;
-                throw new RangeError(iri.value);
-        }
-    }
-    IdentifierMintingStrategy.fromIri = fromIri;
-})(IdentifierMintingStrategy || (IdentifierMintingStrategy = {}));
-//# sourceMappingURL=IdentifierMintingStrategy.js.map

package/dist/enums/TsObjectDeclarationType.d.ts

@@ -1,9 +0,0 @@
-import type { NamedNode } from "@rdfjs/types";
-/**
- * TypeScript enum corresponding to shaclmate:tsObjectDeclarationType, for simpler manipulation.
- */
-export type TsObjectDeclarationType = "class" | "interface";
-export declare namespace TsObjectDeclarationType {
-    function fromIri(iri: NamedNode<"http://purl.org/shaclmate/ontology#_TsObjectDeclarationType_Class" | "http://purl.org/shaclmate/ontology#_TsObjectDeclarationType_Interface">): TsObjectDeclarationType;
-}
-//# sourceMappingURL=TsObjectDeclarationType.d.ts.map

package/dist/enums/TsObjectDeclarationType.js

@@ -1,16 +0,0 @@
-export var TsObjectDeclarationType;
-(function (TsObjectDeclarationType) {
-    function fromIri(iri) {
-        switch (iri.value) {
-            case "http://purl.org/shaclmate/ontology#_TsObjectDeclarationType_Class":
-                return "class";
-            case "http://purl.org/shaclmate/ontology#_TsObjectDeclarationType_Interface":
-                return "interface";
-            default:
-                iri.value;
-                throw new RangeError(iri.value);
-        }
-    }
-    TsObjectDeclarationType.fromIri = fromIri;
-})(TsObjectDeclarationType || (TsObjectDeclarationType = {}));
-//# sourceMappingURL=TsObjectDeclarationType.js.map

package/dist/enums/Visibility.d.ts

@@ -1,6 +0,0 @@
-import type { NamedNode } from "@rdfjs/types";
-export type Visibility = "private" | "protected" | "public";
-export declare namespace Visibility {
-    function fromIri(iri: NamedNode<"http://purl.org/shaclmate/ontology#_Visibility_Private" | "http://purl.org/shaclmate/ontology#_Visibility_Protected" | "http://purl.org/shaclmate/ontology#_Visibility_Public">): Visibility;
-}
-//# sourceMappingURL=Visibility.d.ts.map

package/dist/enums/Visibility.js

@@ -1,18 +0,0 @@
-export var Visibility;
-(function (Visibility) {
-    function fromIri(iri) {
-        switch (iri.value) {
-            case "http://purl.org/shaclmate/ontology#_Visibility_Private":
-                return "private";
-            case "http://purl.org/shaclmate/ontology#_Visibility_Protected":
-                return "protected";
-            case "http://purl.org/shaclmate/ontology#_Visibility_Public":
-                return "public";
-            default:
-                iri.value;
-                throw new RangeError(iri.value);
-        }
-    }
-    Visibility.fromIri = fromIri;
-})(Visibility || (Visibility = {}));
-//# sourceMappingURL=Visibility.js.map

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

@@ -1,33 +0,0 @@
-import { Maybe } from "purify-ts";
-import type { StringType } from "../StringType.js";
-import { type Code } from "../ts-poet-wrapper.js";
-import { AbstractProperty } from "./AbstractProperty.js";
-export declare class IdentifierPrefixProperty extends AbstractProperty<StringType> {
-    private readonly own;
-    readonly filterProperty: AbstractProperty<StringType>["filterProperty"];
-    readonly graphqlField: AbstractProperty<StringType>["graphqlField"];
-    readonly jsonSchema: AbstractProperty<StringType>["jsonSchema"];
-    readonly jsonSignature: Maybe<Code>;
-    readonly kind = "IdentifierPrefixProperty";
-    readonly mutable = false;
-    readonly recursive = false;
-    constructor({ own, ...superParameters }: {
-        own: boolean;
-        type: StringType;
-    } & ConstructorParameters<typeof AbstractProperty>[0]);
-    get constructorParametersSignature(): Maybe<Code>;
-    get declaration(): Maybe<Code>;
-    get equalsFunction(): Maybe<Code>;
-    get getAccessorDeclaration(): Maybe<Code>;
-    constructorStatements({ variables, }: Parameters<AbstractProperty<StringType>["constructorStatements"]>[0]): readonly Code[];
-    fromJsonStatements(): readonly Code[];
-    fromRdfResourceValuesExpression(): Maybe<Code>;
-    hashStatements(): readonly Code[];
-    jsonUiSchemaElement(): Maybe<Code>;
-    sparqlConstructTriplesExpression(): Maybe<Code>;
-    sparqlWherePatternsExpression(): ReturnType<AbstractProperty<StringType>["sparqlWherePatternsExpression"]>;
-    toJsonObjectMemberExpression(): Maybe<Code>;
-    toRdfRdfResourceValuesStatements(): readonly Code[];
-    toStringExpression(): Maybe<Code>;
-}
-//# sourceMappingURL=IdentifierPrefixProperty.d.ts.map

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

@@ -1,92 +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 { snippets } from "../snippets.js";
-import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
-import { code } from "../ts-poet-wrapper.js";
-import { AbstractProperty } from "./AbstractProperty.js";
-export class IdentifierPrefixProperty extends AbstractProperty {
-    own;
-    filterProperty = Maybe.empty();
-    graphqlField = Maybe.empty();
-    jsonSchema = Maybe.empty();
-    jsonSignature = Maybe.empty();
-    kind = "IdentifierPrefixProperty";
-    mutable = false;
-    recursive = false;
-    constructor({ own, ...superParameters }) {
-        super(superParameters);
-        invariant(this.visibility === "protected");
-        this.own = own;
-    }
-    get constructorParametersSignature() {
-        return Maybe.of(code `readonly ${this.name}?: ${this.type.name};`);
-    }
-    get declaration() {
-        if (this.namedObjectType.declarationType === "interface") {
-            return Maybe.empty();
-        }
-        if (!this.own) {
-            return Maybe.empty();
-        }
-        return Maybe.of(code `protected readonly _${this.name}?: ${this.type.name};`);
-    }
-    get equalsFunction() {
-        return this.namedObjectType.declarationType === "class"
-            ? Maybe.of(code `${snippets.strictEquals}`)
-            : Maybe.empty();
-    }
-    get getAccessorDeclaration() {
-        return Maybe.of(code `\
-protected ${!this.own ? "override " : ""} get ${this.name}(): ${this.type.name} {
-  return (this._${this.name} !== undefined) ? this._${this.name} : \`urn:shaclmate:\${this.${syntheticNamePrefix}type}:\`;
-}`);
-    }
-    constructorStatements({ variables, }) {
-        switch (this.namedObjectType.declarationType) {
-            case "class":
-                return this.declaration
-                    .map(() => [code `this._${this.name} = ${variables.parameter};`])
-                    .orDefault([]);
-            case "interface":
-                return [];
-        }
-    }
-    fromJsonStatements() {
-        return [];
-    }
-    fromRdfResourceValuesExpression() {
-        return Maybe.empty();
-    }
-    hashStatements() {
-        return [];
-    }
-    jsonUiSchemaElement() {
-        return Maybe.empty();
-    }
-    sparqlConstructTriplesExpression() {
-        return Maybe.empty();
-    }
-    sparqlWherePatternsExpression() {
-        return Maybe.empty();
-    }
-    toJsonObjectMemberExpression() {
-        return Maybe.empty();
-    }
-    toRdfRdfResourceValuesStatements() {
-        return [];
-    }
-    toStringExpression() {
-        return Maybe.empty();
-    }
-}
-__decorate([
-    Memoize()
-], IdentifierPrefixProperty.prototype, "equalsFunction", null);
-//# sourceMappingURL=IdentifierPrefixProperty.js.map

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

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

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

@@ -1,62 +0,0 @@
-import { code, def, joinCode } from "../ts-poet-wrapper.js";
-import { tsComment } from "../tsComment.js";
-import { NamedObjectType_equalsFunctionOrMethodDeclaration } from "./NamedObjectType_equalsFunctionOrMethodDeclaration.js";
-import { NamedObjectType_hashFunctionOrMethodDeclarations } from "./NamedObjectType_hashFunctionOrMethodDeclarations.js";
-import { NamedObjectType_toJsonFunctionOrMethodDeclaration } from "./NamedObjectType_toJsonFunctionOrMethodDeclaration.js";
-import { NamedObjectType_toRdfResourceFunctionOrMethodDeclaration } from "./NamedObjectType_toRdfResourceFunctionOrMethodDeclaration.js";
-import { NamedObjectType_toStringFunctionOrMethodDeclarations } from "./NamedObjectType_toStringFunctionOrMethodDeclaration.js";
-function NamedObjectType_constructorDeclaration() {
-    const parametersPropertySignatures = this.properties.flatMap((property) => property.constructorParametersSignature.toList());
-    const parametersType = [];
-    if (parametersPropertySignatures.length > 0) {
-        parametersType.push(code `{ ${joinCode(parametersPropertySignatures)} }`);
-    }
-    if (this.parentObjectTypes.length > 0) {
-        // Pass up parameters
-        parametersType.push(code `ConstructorParameters<typeof ${this.parentObjectTypes[0].name}>[0]`);
-    }
-    if (parametersType.length === 0) {
-        parametersType.push(code `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(code `super(parameters);`);
-    }
-    const parametersHasQuestionToken = this.parentObjectTypes.length === 0 &&
-        parametersPropertySignatures.every((propertySignature) => propertySignature.toCodeString([]).indexOf("?:") !== -1);
-    const parametersVariable = code `parameters${parametersHasQuestionToken ? "?" : ""}`;
-    const propertyStatements = this.properties.flatMap((property) => property.constructorStatements({
-        variables: {
-            parameter: code `${parametersVariable}.${property.name}`,
-            parameters: parametersVariable,
-        },
-    }));
-    statements.push(...propertyStatements);
-    return code `\
-${propertyStatements.length === 0 ? "// biome-ignore lint/complexity/noUselessConstructor: Always have a constructor" : ""}
-constructor(${statements.length > 0 ? "parameters" : "_parameters"}${parametersHasQuestionToken ? "?" : ""}: ${joinCode(parametersType, { on: " & " })}) {
-${joinCode(statements)}
-}`;
-}
-export function NamedObjectType_classDeclaration() {
-    this.ensureAtMostOneSuperObjectType();
-    return code `\
-${this.comment
-        .alt(this.label)
-        .map(tsComment)
-        .orDefault("")}export ${this.abstract ? "abstract " : ""}class ${def(this.name)}${this.parentObjectTypes.length > 0 ? ` extends ${this.parentObjectTypes[0].name}` : ""} {
-${joinCode([
-        ...this.properties.flatMap((property) => property.declaration.toList()),
-        NamedObjectType_constructorDeclaration.call(this),
-        ...this.properties.flatMap((property) => property.getAccessorDeclaration.toList()),
-        ...NamedObjectType_equalsFunctionOrMethodDeclaration.call(this).toList(),
-        ...NamedObjectType_hashFunctionOrMethodDeclarations.call(this),
-        ...NamedObjectType_toJsonFunctionOrMethodDeclaration.call(this).toList(),
-        ...NamedObjectType_toRdfResourceFunctionOrMethodDeclaration.call(this).toList(),
-        ...NamedObjectType_toStringFunctionOrMethodDeclarations.call(this),
-    ], { on: "\n\n" })}
-}`;
-}
-//# sourceMappingURL=NamedObjectType_classDeclaration.js.map

package/dist/generators/ts/_NamedObjectType/NamedObjectType_equalsFunctionOrMethodDeclaration.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_equalsFunctionOrMethodDeclaration(this: NamedObjectType): Maybe<Code>;
-//# sourceMappingURL=NamedObjectType_equalsFunctionOrMethodDeclaration.d.ts.map

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

@@ -1,51 +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.ownProperties.length === 0) {
-                // If there's a parent class and no properties in this class, can skip overriding equals
-                return Maybe.empty();
-            }
-            leftVariable = "this";
-            parameters = code `other: ${this.name}`;
-            if (this.parentObjectTypes.length > 0) {
-                chain.push(code `super.${syntheticNamePrefix}equals(other)`);
-                preamble = "override ";
-            }
-            else {
-                preamble = "";
-            }
-            rightVariable = "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 = "left";
-            parameters = code `left: ${this.name}, right: ${this.name}`;
-            preamble = "export function ";
-            rightVariable = "right";
-    }
-    for (const property of this.ownProperties) {
-        property.equalsFunction.ifJust((equalsFunction) => {
-            chain.push(code `(${equalsFunction})(${leftVariable}.${property.name}, ${rightVariable}.${property.name}).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,73 +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.ownShaclProperties.flatMap((property) => property.hashStatements({
-        depth: 0,
-        variables: {
-            hasher: hasherVariable,
-            value: code `${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 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.ownProperties
-        .filter((property) => property.kind !== "ShaclProperty")
-        .flatMap((property) => property.hashStatements({
-        depth: 0,
-        variables: {
-            hasher: hasherVariable,
-            value: code `${this.thisVariable}.${property.name}`,
-        },
-    })));
-    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_toJsonFunctionOrMethodDeclaration.js

@@ -1,59 +0,0 @@
-import { Maybe } from "purify-ts";
-import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
-import { code, joinCode } from "../ts-poet-wrapper.js";
-export function NamedObjectType_toJsonFunctionOrMethodDeclaration() {
-    if (!this.features.has("json")) {
-        return Maybe.empty();
-    }
-    if (this.declarationType === "class" &&
-        this.ownProperties.length === 0 &&
-        this.parentObjectTypes.length > 0) {
-        return Maybe.empty();
-    }
-    const jsonObjectMembers = [];
-    const parameters = [];
-    let preamble;
-    switch (this.declarationType) {
-        case "class":
-            if (this.parentObjectTypes.length > 0) {
-                jsonObjectMembers.push(code `...super.${syntheticNamePrefix}toJson()`);
-                preamble = "override ";
-            }
-            else {
-                preamble = "";
-            }
-            break;
-        case "interface":
-            for (const parentObjectType of this.parentObjectTypes) {
-                jsonObjectMembers.push(code `...${parentObjectType.staticModuleName}.${syntheticNamePrefix}toJson(${this.thisVariable})`);
-            }
-            parameters.push(code `${this.thisVariable}: ${this.name}`);
-            preamble = "export function ";
-            break;
-    }
-    if (this.ownProperties.length > 0) {
-        jsonObjectMembers.push(...this.ownProperties.flatMap((property) => property
-            .toJsonObjectMemberExpression({
-            variables: { value: code `${this.thisVariable}.${property.name}` },
-        })
-            .toList()));
-    }
-    // 20241220: don't add @type until we're doing JSON-LD
-    // switch (this.toRdfTypes.length) {
-    //   case 0:
-    //     break;
-    //   case 1:
-    //     jsonObjectMembers.push(`"@type": "${this.toRdfTypes[0].value}"`);
-    //     break;
-    //   default:
-    //     jsonObjectMembers.push(
-    //       `"@type": ${JSON.stringify(this.toRdfTypes.map((rdfType) => rdfType.value))}`,
-    //     );
-    //     break;
-    // }
-    return Maybe.of(code `\
-${preamble}${syntheticNamePrefix}toJson(${joinCode(parameters, { on: ", " })}): ${this.jsonType().name} {
-  return JSON.parse(JSON.stringify({ ${joinCode(jsonObjectMembers, { on: "," })} } satisfies ${this.jsonType().name}));
-}`);
-}
-//# sourceMappingURL=NamedObjectType_toJsonFunctionOrMethodDeclaration.js.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,62 +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 ownProperty of this.ownProperties) {
-        ownProperty
-            .toStringExpression({
-            variables: { value: code `${this.thisVariable}.${ownProperty.name}` },
-        })
-            .ifJust((ownPropertyToStringExpression) => {
-            propertiesToStringRecordProperties.push(code `${literalOf(ownProperty.name)}: ${ownPropertyToStringExpression}`);
-        });
-    }
-    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