@shaclmate/compiler 4.0.39 → 4.0.41

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

@@ -1,15 +0,0 @@
-import { Maybe } from "purify-ts";
-import { code } from "../ts-poet-wrapper.js";
-export function NamedObjectType_fromRdfResourceValuesFunctionDeclaration() {
-    if (!this.configuration.features.has("Object.fromRdf")) {
-        return Maybe.empty();
-    }
-    return Maybe.of(code `\
-export const fromRdfResourceValues: ${this.reusables.snippets.FromRdfResourceValuesFunction}<${this.name}> = (values, options) => 
-  values.chain(
-    values => values.chainMap(
-      value => value.toResource().chain(resource => ${this.name}.fromRdfResource(resource, options))
-    )
-  );`);
-}
-//# sourceMappingURL=NamedObjectType_fromRdfResourceValuesFunctionDeclaration.js.map

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

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

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

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

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

@@ -1,45 +0,0 @@
-import { code, joinCode } from "../ts-poet-wrapper.js";
-const hasherVariable = code `hasher`;
-export function NamedObjectType_hashFunctionDeclarations() {
-    if (!this.configuration.features.has("Object.hash")) {
-        return [];
-    }
-    const hashOwnShaclPropertiesStatements = this.properties.flatMap((property) => property.kind === "Shacl"
-        ? property.hashStatements({
-            variables: {
-                hasher: hasherVariable,
-                value: property.accessExpression({
-                    variables: { object: this.thisVariable },
-                }),
-            },
-        })
-        : []);
-    const hashShaclPropertiesStatements = [];
-    const hashStatements = [];
-    for (const parentObjectType of this.parentObjectTypes) {
-        hashShaclPropertiesStatements.push(code `${parentObjectType.name}.hashShaclProperties(${hasherVariable}, ${this.thisVariable});`);
-    }
-    hashStatements.push(code `${this.name}.hashShaclProperties(${hasherVariable}, ${this.thisVariable});`);
-    hashShaclPropertiesStatements.push(...hashOwnShaclPropertiesStatements);
-    hashShaclPropertiesStatements.push(code `return ${hasherVariable};`);
-    hashStatements.push(...this.properties
-        .filter((property) => property.kind !== "Shacl")
-        .flatMap((property) => property.hashStatements({
-        variables: {
-            hasher: hasherVariable,
-            value: code `${property.accessExpression({ variables: { object: this.thisVariable } })}`,
-        },
-    })));
-    hashStatements.push(code `return ${hasherVariable};`);
-    return [
-        code `\
-export function hash<HasherT extends ${this.reusables.snippets.Hasher}>(${hasherVariable}: HasherT, ${this.thisVariable}: ${this.name}): HasherT {
-  ${joinCode(hashStatements)}
-}`,
-        code `\
-export function hashShaclProperties<HasherT extends ${this.reusables.snippets.Hasher}>(${hasherVariable}: HasherT, ${this.thisVariable}: ${this.name}): HasherT {
-  ${joinCode(hashShaclPropertiesStatements)}
-}`,
-    ];
-}
-//# sourceMappingURL=NamedObjectType_hashFunctionDeclarations.js.map

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

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

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

@@ -1,16 +0,0 @@
-import { code, joinCode } from "../ts-poet-wrapper.js";
-import { tsComment } from "../tsComment.js";
-export function NamedObjectType_interfaceDeclaration() {
-    return code `\
-${this.comment
-        .alt(this.label)
-        .map(tsComment)
-        .orDefault("")}export interface ${this.name}${this.parentObjectTypes.length > 0
-        ? ` extends ${this.parentObjectTypes
-            .map((parentObjectType) => parentObjectType.name)
-            .join(", ")}`
-        : ""} {
-  ${joinCode(this.properties.map((property) => property.declaration), { on: "\n\n" })}
-}`;
-}
-//# sourceMappingURL=NamedObjectType_interfaceDeclaration.js.map

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

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

@@ -1,17 +0,0 @@
-import { Maybe } from "purify-ts";
-import { code } from "../ts-poet-wrapper.js";
-export function NamedObjectType_isTypeFunctionDeclaration() {
-    if (!this.configuration.features.has("Object.type")) {
-        return Maybe.empty();
-    }
-    return Maybe.of(code `\
-export function is${this.name}(object: ${this.configuration.syntheticNamePrefix}Object): object is ${this.name} {
-  switch (object.${this._discriminantProperty.name}) {
-    ${this._discriminantProperty.type.descendantValues
-        .concat(this._discriminantProperty.type.ownValues)
-        .map((value) => `case "${value}":`)
-        .join("\n")} return true; default: return false;
-  }
-}`);
-}
-//# sourceMappingURL=NamedObjectType_isTypeFunctionDeclaration.js.map

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

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

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

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

@@ -1,16 +0,0 @@
-import { Maybe } from "purify-ts";
-import { code, joinCode } from "../ts-poet-wrapper.js";
-export function NamedObjectType_jsonTypeAliasDeclaration() {
-    if (!this.configuration.features.has("Object.JSON.type")) {
-        return Maybe.empty();
-    }
-    const members = [];
-    if (this.properties.length > 0) {
-        members.push(code `{ ${joinCode(this.properties.flatMap((property) => property.jsonSignature.toList()), { on: ";" })} }`);
-    }
-    for (const parentObjectType of this.parentObjectTypes) {
-        members.push(code `${parentObjectType.jsonType().name}`);
-    }
-    return Maybe.of(code `export type Json = ${members.length > 0 ? joinCode(members, { on: " & " }) : "object"};`);
-}
-//# sourceMappingURL=NamedObjectType_jsonTypeAliasDeclaration.js.map

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

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

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

@@ -1,12 +0,0 @@
-import { Maybe } from "purify-ts";
-import { code, joinCode } from "../ts-poet-wrapper.js";
-export function NamedObjectType_schemaVariableStatement() {
-    if (!this.configuration.features.has("Object.schema")) {
-        return Maybe.empty();
-    }
-    return Maybe.of(code `\
-export const schema = { properties: { ${joinCode(this.parentObjectTypes
-        .map((parentObjectType) => code `...${parentObjectType.name}.schema.properties`)
-        .concat(this.properties.flatMap(property => property.schema.toList().map(propertySchema => code `${property.name}: ${propertySchema}`))), { on: ", " })} } } as const;`);
-}
-//# sourceMappingURL=NamedObjectType_schemaVariableStatement.js.map

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

@@ -1,12 +0,0 @@
-import { Maybe } from "purify-ts";
-import { code } from "../ts-poet-wrapper.js";
-export function NamedObjectType_sparqlConstructQueryStringFunctionDeclaration() {
-    if (!this.configuration.features.has("Object.SPARQL")) {
-        return Maybe.empty();
-    }
-    return Maybe.of(code `\
-export function sparqlConstructQueryString(parameters: Parameters<typeof ${this.name}.sparqlConstructQuery>[0] & ${this.reusables.imports.sparqljs}.GeneratorOptions): string {
-  return new ${this.reusables.imports.sparqljs}.Generator(parameters).stringify(${this.name}.sparqlConstructQuery(parameters));
-}`);
-}
-//# sourceMappingURL=NamedObjectType_sparqlConstructQueryStringFunctionDeclaration.js.map

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

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

@@ -1,41 +0,0 @@
-import { Maybe } from "purify-ts";
-import { code, joinCode } from "../ts-poet-wrapper.js";
-export function NamedObjectType_toJsonFunctionDeclaration() {
-    if (!this.configuration.features.has("Object.toJson")) {
-        return Maybe.empty();
-    }
-    const jsonObjectMembers = [];
-    for (const parentObjectType of this.parentObjectTypes) {
-        jsonObjectMembers.push(code `...${parentObjectType.name}.toJson(${this.thisVariable})`);
-    }
-    if (this.properties.length > 0) {
-        jsonObjectMembers.push(...this.properties.flatMap((property) => property
-            .toJsonInitializer({
-            variables: {
-                value: property.accessExpression({
-                    variables: { object: this.thisVariable },
-                }),
-            },
-        })
-            .toList()));
-    }
-    const returnType = this.jsonType().name;
-    // 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 `\
-export function toJson(${this.thisVariable}: ${this.name}): ${returnType} {
-  return JSON.parse(JSON.stringify({ ${joinCode(jsonObjectMembers, { on: "," })} } satisfies ${this.jsonType().name}));
-}`);
-}
-//# sourceMappingURL=NamedObjectType_toJsonFunctionDeclaration.js.map

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

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

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

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

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

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

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

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

@@ -1,25 +0,0 @@
-import { code } from "../ts-poet-wrapper.js";
-export function identifierTypeDeclarations() {
-    if (!this.configuration.features.has("Object.type")) {
-        return [];
-    }
-    const ancestorObjectTypeWithSameIdentifierType = this.ancestorObjectTypes.find((ancestorObjectType) => ancestorObjectType.identifierType.name === this.identifierType.name);
-    if (ancestorObjectTypeWithSameIdentifierType) {
-        // This object type's identifier type has the same identifier type as an ancestor object type,
-        // so just reuse the latter.
-        return [
-            code `export type Identifier = ${ancestorObjectTypeWithSameIdentifierType.identifierTypeAlias};`,
-            code `export const Identifier = ${ancestorObjectTypeWithSameIdentifierType.identifierTypeAlias};`,
-        ];
-    }
-    // Bespoke identifier type and associated functions
-    return [
-        code `export type Identifier = ${this.identifierType.name};`,
-        code `\
-export namespace Identifier {
-  export const parse = ${this.identifierType.parseFunction};
-  export const stringify = ${this.identifierType.stringifyFunction};
-}`,
-    ];
-}
-//# sourceMappingURL=identifierTypeDeclarations.js.map

package/dist/generators/ts/_snippets/snippets_convertToArray.d.ts

@@ -1,3 +0,0 @@
-import type { SnippetFactory } from "../SnippetFactory.js";
-export declare const snippets_convertToArray: SnippetFactory;
-//# sourceMappingURL=snippets_convertToArray.d.ts.map

package/dist/generators/ts/_snippets/snippets_convertToArray.js

@@ -1,8 +0,0 @@
-import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-export const snippets_convertToArray = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}convertToArray`, code `\
-function ${syntheticNamePrefix}convertToArray<ItemSourceT, ItemTargetT, Readonly extends boolean>(convertToItem: ${snippets.ConversionFunction}<ItemSourceT, ItemTargetT>, _readonly: Readonly) {
-  type EitherR = Readonly extends true ? ReadonlyArray<ItemTargetT> : Array<ItemTargetT>;
-  return (value: readonly ItemSourceT[] | undefined): ${imports.Either}<Error, EitherR> => 
-    (typeof value === "undefined" ? ${imports.Either}.of([]) : ${imports.Either}.sequence(value.map(convertToItem))) as ${imports.Either}<Error, EitherR>;
-}`);
-//# sourceMappingURL=snippets_convertToArray.js.map