@shaclmate/compiler 4.0.40 → 4.0.42

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

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

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

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

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

@@ -1,10 +0,0 @@
-import { Maybe } from "purify-ts";
-import { code } from "../ts-poet-wrapper.js";
-export function ObjectType_fromRdfTypeVariableStatement() {
-    if (!this.configuration.features.has("Object.fromRdf")) {
-        return Maybe.empty();
-    }
-    return this.fromRdfType.map((fromRdfType) => code `\
-export const fromRdfType: ${this.reusables.imports.NamedNode}<string> = ${this.rdfjsTermExpression(fromRdfType)};`);
-}
-//# sourceMappingURL=ObjectType_fromRdfTypeVariableStatement.js.map

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

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

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

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

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

@@ -1,45 +0,0 @@
-import { code, joinCode } from "../ts-poet-wrapper.js";
-const hasherVariable = code `hasher`;
-export function ObjectType_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.alias.unsafeCoerce()}.hashShaclProperties(${hasherVariable}, ${this.thisVariable});`);
-    }
-    hashStatements.push(code `${this.alias.unsafeCoerce()}.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.expression}): HasherT {
-  ${joinCode(hashStatements)}
-}`,
-        code `\
-export function hashShaclProperties<HasherT extends ${this.reusables.snippets.Hasher}>(${hasherVariable}: HasherT, ${this.thisVariable}: ${this.expression}): HasherT {
-  ${joinCode(hashShaclPropertiesStatements)}
-}`,
-    ];
-}
-//# sourceMappingURL=ObjectType_hashFunctionDeclarations.js.map

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

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

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

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

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

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

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

@@ -1,31 +0,0 @@
-import { Maybe } from "purify-ts";
-import { code, joinCode } from "../ts-poet-wrapper.js";
-export function ObjectType_jsonSchemaFunctionDeclaration() {
-    if (!this.configuration.features.has("Object.JSON.schema")) {
-        return Maybe.empty();
-    }
-    let properties = [];
-    for (const parentObjectType of this.parentObjectTypes) {
-        properties.push(code `...${parentObjectType.jsonSchema({ context: "type" })}.shape`);
-    }
-    if (this.properties.length > 0) {
-        properties = properties.concat(this.properties
-            .flatMap((property) => property.jsonSchema.toList())
-            .map(({ key, schema }) => code `"${key}": ${schema}`));
-    }
-    const meta = {
-    // id: this.name,
-    };
-    this.comment.ifJust((description) => {
-        meta["description"] = description;
-    });
-    this.label.ifJust((label) => {
-        meta["title"] = label;
-    });
-    // ${this.properties.every((property) => !property.mutable) ? `.readonly()` : ""}
-    return Maybe.of(code `\
-export function schema() {
-  return ${this.reusables.imports.z}.object({${joinCode(properties, { on: "," })}}).meta(${meta}) satisfies ${this.reusables.imports.z}.ZodType<Json>;
-}`);
-}
-//# sourceMappingURL=ObjectType_jsonSchemaFunctionDeclaration.js.map

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

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

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

@@ -1,16 +0,0 @@
-import { Maybe } from "purify-ts";
-import { code, joinCode } from "../ts-poet-wrapper.js";
-export function ObjectType_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=ObjectType_jsonTypeAliasDeclaration.js.map

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

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

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

@@ -1,17 +0,0 @@
-import { Maybe } from "purify-ts";
-import { code, joinCode } from "../ts-poet-wrapper.js";
-export function ObjectType_jsonUiSchemaFunctionDeclaration() {
-    if (!this.configuration.features.has("Object.JSON.uiSchema")) {
-        return Maybe.empty();
-    }
-    const variables = { scopePrefix: code `scopePrefix` };
-    const elements = this.parentObjectTypes
-        .map((parentObjectType) => code `${parentObjectType.alias.unsafeCoerce()}.Json.uiSchema({ scopePrefix })`)
-        .concat(this.properties.flatMap((property) => property.jsonUiSchemaElement({ variables }).toList()));
-    return Maybe.of(code `\
-export function uiSchema(parameters?: { scopePrefix?: string }): any {
-  const scopePrefix = parameters?.scopePrefix ?? "#";
-  return { "elements": [ ${joinCode(elements, { on: "," })} ], label: "${this.label.orDefault(this.alias.unsafeCoerce())}", type: "Group" };
-}`);
-}
-//# sourceMappingURL=ObjectType_jsonUiSchemaFunctionDeclaration.js.map

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

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

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

@@ -1,14 +0,0 @@
-import { Maybe } from "purify-ts";
-import { code, joinCode } from "../ts-poet-wrapper.js";
-export function ObjectType_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.alias.unsafeCoerce()}.schema.properties`)
-        .concat(this.properties.flatMap((property) => property.schema
-        .toList()
-        .map((propertySchema) => code `${property.name}: ${propertySchema}`))), { on: ", " })} } } as const;`);
-}
-//# sourceMappingURL=ObjectType_schemaVariableStatement.js.map

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

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

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

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

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

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

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

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

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

@@ -1,36 +0,0 @@
-import { code, joinCode } from "../ts-poet-wrapper.js";
-export function ObjectType_toStringFunctionDeclarations() {
-    if (!this.configuration.features.has("Object.toString")) {
-        return [];
-    }
-    let propertiesToStringInitializers = [];
-    if (this.parentObjectTypes.length > 0) {
-        for (const parentObjectType of this.parentObjectTypes) {
-            propertiesToStringInitializers.push(code `...${parentObjectType.alias.unsafeCoerce()}._propertiesToStrings(${this.thisVariable})`);
-        }
-    }
-    propertiesToStringInitializers = propertiesToStringInitializers.concat(this.properties.flatMap((property) => property
-        .toStringInitializer({
-        variables: {
-            value: property.accessExpression({
-                variables: { object: this.thisVariable },
-            }),
-        },
-    })
-        .toList()));
-    const propertiesToStringsReturnExpression = code `${this.reusables.snippets.compactRecord}({${joinCode(propertiesToStringInitializers, { on: "," })}})`;
-    const toStringReturnExpression = (propertiesToStrings) => code `\`${this.alias.unsafeCoerce()}(\${JSON.stringify(${propertiesToStrings})})\``;
-    const syntheticNamePrefix = this.configuration.syntheticNamePrefix;
-    return [
-        // Use overloads to allow the function to be attached to an instance or used freestanding
-        code `\
-export function _propertiesToStrings(${this.thisVariable}: ${this.expression}): Record<string, string> {
-  return ${propertiesToStringsReturnExpression};
-}`,
-        code `\
-export function ${syntheticNamePrefix}toString(${this.thisVariable}: ${this.expression}): string {
-  return ${toStringReturnExpression(code `_propertiesToStrings(${this.thisVariable})`)};
-}`,
-    ];
-}
-//# sourceMappingURL=ObjectType_toStringFunctionDeclarations.js.map

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

@@ -1,11 +0,0 @@
-import { Maybe } from "purify-ts";
-import { code } from "../ts-poet-wrapper.js";
-export function ObjectType_valueSparqlConstructTriplesFunctionDeclaration() {
-    if (!this.configuration.features.has("Object.SPARQL")) {
-        return Maybe.empty();
-    }
-    return Maybe.of(code `\
-export const valueSparqlConstructTriples: ${this.reusables.snippets.ValueSparqlConstructTriplesFunction}<${this.filterType}, ${this.schemaType}> = ({ filter, ignoreRdfType, valueVariable, variablePrefix }) =>
-  ${this.alias.unsafeCoerce()}.focusSparqlConstructTriples({ filter, focusIdentifier: valueVariable, ignoreRdfType, variablePrefix });`);
-}
-//# sourceMappingURL=ObjectType_valueSparqlConstructTriplesFunctionDeclaration.js.map

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

@@ -1,13 +0,0 @@
-import { Maybe } from "purify-ts";
-import { code } from "../ts-poet-wrapper.js";
-export function ObjectType_valueSparqlWherePatternsFunctionDeclaration() {
-    if (!this.configuration.features.has("Object.SPARQL")) {
-        return Maybe.empty();
-    }
-    return Maybe.of(code `\
-export const valueSparqlWherePatterns: ${this.reusables.snippets.ValueSparqlWherePatternsFunction}<${this.filterType}, ${this.schemaType}> = ({ filter, ignoreRdfType, preferredLanguages, propertyPatterns, valueVariable, variablePrefix }) =>
-  (propertyPatterns as readonly ${this.reusables.snippets.SparqlPattern}[]).concat(
-    ${this.alias.unsafeCoerce()}.focusSparqlWherePatterns({ filter, focusIdentifier: valueVariable, ignoreRdfType, preferredLanguages, variablePrefix })
-  );`);
-}
-//# sourceMappingURL=ObjectType_valueSparqlWherePatternsFunctionDeclaration.js.map

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

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

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

@@ -1,27 +0,0 @@
-import { codeEquals } from "../codeEquals.js";
-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.kind === this.identifierType.kind &&
-        codeEquals(ancestorObjectType.identifierType.expression, this.identifierType.expression));
-    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.expression};`,
-        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_LazyObject.d.ts

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

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

@@ -1,22 +0,0 @@
-import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-export const snippets_LazyObject = ({ imports, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}LazyObject`, code `\
-/**
- * Type of lazy properties that return a single required object. This is a class instead of an interface so it can be instanceof'd elsewhere.
- */
-export class ${syntheticNamePrefix}LazyObject<ObjectIdentifierT extends ${imports.BlankNode} | ${imports.NamedNode}, PartialObjectT extends { ${syntheticNamePrefix}identifier: () => ObjectIdentifierT }, ResolvedObjectT extends { ${syntheticNamePrefix}identifier: () => ObjectIdentifierT }> {
-  readonly partial: PartialObjectT;
-  private readonly resolver: (identifier: ObjectIdentifierT, options?: { preferredLanguages?: readonly string[] }) => Promise<${imports.Either}<Error, ResolvedObjectT>>;
-
-  constructor({ partial, resolver }: {
-    partial: PartialObjectT
-    resolver: (identifier: ObjectIdentifierT, options?: { preferredLanguages?: readonly string[] }) => Promise<${imports.Either}<Error, ResolvedObjectT>>,
-  }) {
-    this.partial = partial;
-    this.resolver = resolver;
-  }
-
-  resolve(options?: { preferredLanguages?: readonly string[] }): Promise<${imports.Either}<Error, ResolvedObjectT>> {
-    return this.resolver(this.partial.${syntheticNamePrefix}identifier(), options);
-  }
-}`);
-//# sourceMappingURL=snippets_LazyObject.js.map

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

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

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

@@ -1,25 +0,0 @@
-import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-export const snippets_LazyObjectOption = ({ imports, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}LazyObjectOption`, code `\
-/**
- * Type of lazy properties that return a single optional object. This is a class instead of an interface so it can be instanceof'd elsewhere.
- */
-export class ${syntheticNamePrefix}LazyObjectOption<ObjectIdentifierT extends ${imports.BlankNode} | ${imports.NamedNode}, PartialObjectT extends { ${syntheticNamePrefix}identifier: () => ObjectIdentifierT }, ResolvedObjectT extends { ${syntheticNamePrefix}identifier: () => ObjectIdentifierT }> {
-  readonly partial: ${imports.Maybe}<PartialObjectT>;
-  private readonly resolver: (identifier: ObjectIdentifierT, options?: { preferredLanguages?: readonly string[] }) => Promise<${imports.Either}<Error, ResolvedObjectT>>;
-
-  constructor({ partial, resolver }: {
-    partial: ${imports.Maybe}<PartialObjectT>
-    resolver: (identifier: ObjectIdentifierT, options?: { preferredLanguages?: readonly string[] }) => Promise<${imports.Either}<Error, ResolvedObjectT>>,
-  }) {
-    this.partial = partial;
-    this.resolver = resolver;
-  }
-
-  async resolve(options?: { preferredLanguages?: readonly string[] }): Promise<${imports.Either}<Error, ${imports.Maybe}<ResolvedObjectT>>> {
-    if (this.partial.isNothing()) {
-      return ${imports.Right}(${imports.Maybe}.empty());
-    }
-    return (await this.resolver(this.partial.unsafeCoerce().${syntheticNamePrefix}identifier(), options)).map(${imports.Maybe}.of);
-  }
-}`);
-//# sourceMappingURL=snippets_LazyObjectOption.js.map

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

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

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

@@ -1,40 +0,0 @@
-import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-export const snippets_LazyObjectSet = ({ imports, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}LazyObjectSet`, code `\
-/**
- * Type of lazy properties that return a set of objects. This is a class instead of an interface so it can be instanceof'd elsewhere.
- */
-export class ${syntheticNamePrefix}LazyObjectSet<ObjectIdentifierT extends ${imports.BlankNode} | ${imports.NamedNode}, PartialObjectT extends { ${syntheticNamePrefix}identifier: () => ObjectIdentifierT }, ResolvedObjectT extends { ${syntheticNamePrefix}identifier: () => ObjectIdentifierT }> {
-  readonly partials: readonly PartialObjectT[];
-  private readonly resolver: (identifiers: readonly ObjectIdentifierT[], options?: { preferredLanguages?: readonly string[] }) => Promise<${imports.Either}<Error, readonly ResolvedObjectT[]>>;
-
-  constructor({ partials, resolver }: {
-    partials: readonly PartialObjectT[]
-    resolver: (identifiers: readonly ObjectIdentifierT[], options?: { preferredLanguages?: readonly string[] }) => Promise<${imports.Either}<Error, readonly ResolvedObjectT[]>>,
-  }) {
-    this.partials = partials;
-    this.resolver = resolver;
-  }
-
-  get length(): number {
-    return this.partials.length;
-  }
-
-  async resolve(options?: { limit?: number; offset?: number; preferredLanguages?: readonly string[] }): Promise<${imports.Either}<Error, readonly ResolvedObjectT[]>> {
-    if (this.partials.length === 0) {
-      return ${imports.Right}([]);
-    }
-
-    const limit = options?.limit ?? Number.MAX_SAFE_INTEGER;
-    if (limit <= 0) {
-      return ${imports.Right}([]);
-    }
-
-    let offset = options?.offset ?? 0;
-    if (offset < 0) {
-      offset = 0;
-    }
-
-    return await this.resolver(this.partials.slice(offset, offset + limit).map(partial => partial.${syntheticNamePrefix}identifier()), { preferredLanguages: options?.preferredLanguages });
-  }
-}`);
-//# sourceMappingURL=snippets_LazyObjectSet.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

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

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

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

@@ -1,15 +0,0 @@
-import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-export const snippets_convertToLazyObject = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}convertToLazyObject`, code `\
-function ${syntheticNamePrefix}convertToLazyObject<ObjectIdentifierT extends ${imports.BlankNode} | ${imports.NamedNode}, PartialObjectT extends { ${syntheticNamePrefix}identifier: () => ObjectIdentifierT }, ResolvedObjectT extends { ${syntheticNamePrefix}identifier: () => ObjectIdentifierT }>(resolvedToPartial: (resolved: ResolvedObjectT) => PartialObjectT) {
-  return (value: ${snippets.LazyObject}<ObjectIdentifierT, PartialObjectT, ResolvedObjectT> | ResolvedObjectT): ${imports.Either}<Error, ${snippets.LazyObject}<ObjectIdentifierT, PartialObjectT, ResolvedObjectT>> => {
-    if (value instanceof ${snippets.LazyObject}) {
-      return ${imports.Either}.of(value);
-    }
-
-    return ${imports.Either}.of(new ${snippets.LazyObject}({
-      partial: resolvedToPartial(value),
-      resolver: async () => ${imports.Right}(value)
-    }));
-  };
-}`);
-//# sourceMappingURL=snippets_convertToLazyObject.js.map

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

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

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

@@ -1,31 +0,0 @@
-import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-export const snippets_convertToLazyObjectOption = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}convertToLazyObjectOption`, code `\
-function ${syntheticNamePrefix}convertToLazyObjectOption<ObjectIdentifierT extends ${imports.BlankNode} | ${imports.NamedNode}, PartialObjectT extends { ${syntheticNamePrefix}identifier: () => ObjectIdentifierT }, ResolvedObjectT extends { ${syntheticNamePrefix}identifier: () => ObjectIdentifierT }>(resolvedToPartial: (resolved: ResolvedObjectT) => PartialObjectT) {
-  return (value: ${snippets.LazyObjectOption}<ObjectIdentifierT, PartialObjectT, ResolvedObjectT> | ${imports.Maybe}<ResolvedObjectT> | ResolvedObjectT | undefined): ${imports.Either}<Error, ${snippets.LazyObjectOption}<ObjectIdentifierT, PartialObjectT, ResolvedObjectT>> => {
-    switch (typeof value) {
-      case "object": {
-        if (value instanceof ${snippets.LazyObjectOption}) {
-          return ${imports.Either}.of(value);
-        }
-
-        if (${imports.Maybe}.isMaybe(value)) {
-          return ${imports.Either}.of(new ${snippets.LazyObjectOption}<ObjectIdentifierT, PartialObjectT, ResolvedObjectT>({
-            partial: value.map(resolvedToPartial),
-            resolver: async () => ${imports.Right}(value.unsafeCoerce())
-          }));
-        }
-
-        return ${imports.Either}.of(new ${snippets.LazyObjectOption}<ObjectIdentifierT, PartialObjectT, ResolvedObjectT>({
-          partial: ${imports.Maybe}.of(resolvedToPartial(value)),
-          resolver: async () => ${imports.Right}(value)
-        }));
-      }
-      case "undefined":
-        return ${imports.Either}.of(new ${snippets.LazyObjectOption}<ObjectIdentifierT, PartialObjectT, ResolvedObjectT>({
-          partial: ${imports.Maybe}.empty(),
-          resolver: async () => { throw new Error("should never be called"); }
-        }));
-    }
-  };
-}`);
-//# sourceMappingURL=snippets_convertToLazyObjectOption.js.map

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

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

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

@@ -1,25 +0,0 @@
-import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-export const snippets_convertToLazyObjectSet = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}convertToLazyObjectSet`, code `\
-function ${syntheticNamePrefix}convertToLazyObjectSet<ObjectIdentifierT extends ${imports.BlankNode} | ${imports.NamedNode}, PartialObjectT extends { ${syntheticNamePrefix}identifier: () => ObjectIdentifierT }, ResolvedObjectT extends { ${syntheticNamePrefix}identifier: () => ObjectIdentifierT }>(resolvedToPartial: (resolved: ResolvedObjectT) => PartialObjectT) {
-  return (value: ${snippets.LazyObjectSet}<ObjectIdentifierT, PartialObjectT, ResolvedObjectT> | readonly ResolvedObjectT[] | undefined): ${imports.Either}<Error, ${snippets.LazyObjectSet}<ObjectIdentifierT, PartialObjectT, ResolvedObjectT>> => {
-    switch (typeof value) {
-      case "object": {
-        if (value instanceof ${snippets.LazyObjectSet}) {
-          return ${imports.Either}.of(value);
-        }
-
-        const captureValue = value;
-        return ${imports.Either}.of(new ${snippets.LazyObjectSet}<ObjectIdentifierT, PartialObjectT, ResolvedObjectT>({
-          partials: value.map(resolvedToPartial),
-          resolver: async () => ${imports.Right}(captureValue)
-        }));
-      }
-      case "undefined":
-        return ${imports.Either}.of(new ${snippets.LazyObjectSet}<ObjectIdentifierT, PartialObjectT, ResolvedObjectT>({
-          partials: [],
-          resolver: async () => ${imports.Right}([])
-        }));
-    }
-  };
-}`);
-//# sourceMappingURL=snippets_convertToLazyObjectSet.js.map

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

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