@shaclmate/compiler 4.0.50 → 4.0.51

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

@@ -0,0 +1,284 @@
+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 { Memoize } from "typescript-memoize";
+import { code, joinCode, literalOf } from "../ts-poet-wrapper.js";
+import { tsComment } from "../tsComment.js";
+import { AbstractProperty } from "./AbstractProperty.js";
+export class ShaclProperty extends AbstractProperty {
+    comment;
+    description;
+    display;
+    label;
+    kind = "Shacl";
+    mutable;
+    path;
+    recursive;
+    constructor({ comment, description, display, label, mutable, path, recursive, ...superParameters }) {
+        super(superParameters);
+        this.comment = comment;
+        this.description = description;
+        this.display = display;
+        this.label = label;
+        this.mutable = mutable;
+        this.path = path;
+        this.recursive = recursive;
+    }
+    get constructorParameter() {
+        const conversionFunction = this.type.conversionFunction.extract();
+        if (!conversionFunction) {
+            return Maybe.of({
+                hasQuestionToken: false,
+                signature: code `readonly ${this.name}: ${this.type.expression};`,
+            });
+        }
+        let hasQuestionToken = false;
+        const typeExpressions = [];
+        for (const type of conversionFunction.sourceTypes) {
+            if (type.jsType.typeof === "undefined") {
+                hasQuestionToken = true;
+            }
+            else {
+                typeExpressions.push(code `${type.expression}`);
+            }
+        }
+        return Maybe.of({
+            hasQuestionToken,
+            signature: code `readonly ${this.name}${hasQuestionToken ? "?" : ""}: ${joinCode(typeExpressions, { on: "|" })};`,
+        });
+    }
+    get declaration() {
+        let declaration = code `${!this.mutable ? "readonly " : ""}${this.name}: ${this.type.expression};`;
+        this.comment
+            .alt(this.description)
+            .alt(this.label)
+            .map(tsComment)
+            .ifJust((comment) => {
+            declaration = code `${comment}${declaration}`;
+        });
+        return declaration;
+    }
+    get filterProperty() {
+        return Maybe.of({
+            name: this.name,
+            type: this.type.filterType,
+        });
+    }
+    get graphqlField() {
+        const args = this.type.graphqlArgs;
+        const argsVariable = args.isJust() ? code `args` : code `_args`;
+        return Maybe.of({
+            args,
+            description: this.comment.map(JSON.stringify),
+            name: this.name,
+            resolve: code `(source, ${argsVariable}) => ${this.type.graphqlResolveExpression({ variables: { args: argsVariable, value: code `source.${this.name}` } })}`,
+            type: this.type.graphqlType.expression,
+        });
+    }
+    get hashFunctionParameter() {
+        return this.declaration;
+    }
+    get jsonSchema() {
+        let schema = this.type.jsonSchema({
+            context: "property",
+        });
+        const meta = {
+        // id: `${this.namedObjectType.name}-${this.name}`, // id's must be unique
+        };
+        this.comment.alt(this.description).ifJust((description) => {
+            meta["description"] = description;
+        });
+        this.label.ifJust((label) => {
+            meta["title"] = label;
+        });
+        if (Object.keys(meta).length > 0) {
+            schema = code `${schema}.meta(${meta})`;
+        }
+        return Maybe.of({
+            key: this.name,
+            schema,
+        });
+    }
+    get jsonSignature() {
+        const typeJsonType = this.type.jsonType();
+        return Maybe.of(code `${!this.mutable ? "readonly " : ""}${this.name}${typeJsonType.optional ? "?" : ""}: ${typeJsonType.requiredExpression}`);
+    }
+    get schema() {
+        const initializers = [code `kind: ${literalOf(this.kind)}`];
+        if (this.configuration.features.has("Object.fromRdf") ||
+            this.configuration.features.has("Object.toRdf")) {
+            initializers.push(code `path: ${this.propertyPathToCode(this.path)}`);
+        }
+        // Use a getter if the type is recursive or the type is an object type, which may have forward references in the file
+        if (this.recursive || this.type.referencesNamedType) {
+            initializers.push(code `get type() { return ${this.type.schema}; }`);
+        }
+        else {
+            initializers.push(code `type: ${this.type.schema}`);
+        }
+        return Maybe.of(code `{ ${joinCode(initializers, { on: ", " })} }`);
+    }
+    get schemaType() {
+        const initializers = [code `readonly kind: ${literalOf(this.kind)}`];
+        if (this.configuration.features.has("Object.fromRdf") ||
+            this.configuration.features.has("Object.toRdf")) {
+            initializers.push(code `readonly path: ${this.reusables.snippets.PropertyPath}`);
+        }
+        initializers.push(code `readonly type: ${this.type.schemaType}`);
+        return Maybe.of(code `{ ${joinCode(initializers, { on: ", " })} }`);
+    }
+    get schemaVariable() {
+        return this.objectType.name
+            .map((name) => code `${name}.schema.properties.${this.name}`)
+            .orDefaultLazy(() => this.schema.unsafeCoerce());
+    }
+    get typeSchemaVariable() {
+        return this.objectType.name
+            .map((name) => code `${name}.schema.properties.${this.name}.type`)
+            .orDefaultLazy(() => this.type.schema);
+    }
+    constructorInitializer({ variables, }) {
+        const parameterVariable = code `${variables.parameters}.${this.name}`;
+        const conversionFunction = this.type.conversionFunction.extract()?.code;
+        const validationFunction = this.type.validationFunction.extract();
+        let rhs;
+        if (conversionFunction && validationFunction) {
+            rhs = code `${conversionFunction}(${parameterVariable}).chain(value => ${validationFunction}(${this.typeSchemaVariable}, value))`;
+        }
+        else if (conversionFunction) {
+            rhs = code `${conversionFunction}(${parameterVariable})`;
+        }
+        else if (validationFunction) {
+            rhs = code `${validationFunction}(${this.typeSchemaVariable}, ${parameterVariable})`;
+        }
+        else {
+            rhs = code `${this.reusables.imports.Either}.of(${parameterVariable})`;
+        }
+        return Maybe.of(code `${this.name}: ${rhs}`);
+    }
+    fromJsonInitializer({ variables, }) {
+        return Maybe.of(code `${this.name}: ${this.type.fromJsonExpression({
+            variables: { value: code `${variables.jsonObject}["${this.name}"]` },
+        })}`);
+    }
+    fromRdfResourceValuesInitializer({ variables, }) {
+        return Maybe.of(code `${this.name}:
+        ${this.reusables.snippets.shaclPropertyFromRdf}<${this.type.expression}, ${this.type.schemaType}>({
+          ...${variables.options},
+          focusResource: ${variables.focusResource},
+          ignoreRdfType: true,
+          propertySchema: ${this.schemaVariable},
+          typeFromRdfResourceValues: ${this.type.fromRdfResourceValuesFunction} 
+        })`);
+    }
+    hashStatements({ variables, }) {
+        return [
+            code `${this.type.hashFunction}(${variables.hasher}, ${variables.value});`,
+        ];
+    }
+    jsonUiSchemaElement({ variables, }) {
+        const scope = code `\`\${${variables.scopePrefix}}/properties/${this.name}\``;
+        return this.type
+            .jsonUiSchemaElement({ variables: { scopePrefix: scope } })
+            .altLazy(() => Maybe.of(code `{ ${this.label.isJust() ? `label: "${this.label.unsafeCoerce()}", ` : ""}scope: ${scope}, type: "Control" }`));
+    }
+    sparqlConstructTriplesExpression({ variables, }) {
+        return Maybe.of(code `${this.reusables.snippets.shaclPropertySparqlConstructTriples}(${{
+            filter: this.filterProperty
+                .map(({ name }) => code `${variables.filter}?.${name}`)
+                .extract(),
+            focusIdentifier: variables.focusIdentifier,
+            ignoreRdfType: true,
+            propertyName: this.name,
+            propertySchema: this.schemaVariable,
+            typeSparqlConstructTriples: this.type.valueSparqlConstructTriplesFunction,
+            variablePrefix: variables.variablePrefix,
+        }})`);
+    }
+    sparqlWherePatternsExpression({ variables, }) {
+        return Maybe.of({
+            patterns: code `${this.reusables.snippets.shaclPropertySparqlWherePatterns}(${{
+                filter: this.filterProperty
+                    .map(({ name }) => code `${variables.filter}?.${name}`)
+                    .extract(),
+                focusIdentifier: variables.focusIdentifier,
+                ignoreRdfType: true,
+                preferredLanguages: variables.preferredLanguages,
+                propertyName: this.name,
+                propertySchema: this.schemaVariable,
+                typeSparqlWherePatterns: this.type.valueSparqlWherePatternsFunction,
+                variablePrefix: variables.variablePrefix,
+            }})`,
+        });
+    }
+    toJsonInitializer(parameters) {
+        return Maybe.of(code `${this.name}: ${this.type.toJsonExpression(parameters)}`);
+    }
+    toRdfRdfResourceValuesStatements({ variables, }) {
+        switch (this.path.termType) {
+            case "NamedNode":
+                break;
+            case "InversePath":
+                if (this.path.path.termType === "NamedNode") {
+                    break;
+                }
+                return [];
+            default:
+                return [];
+        }
+        const propertyPath = this.objectType.name
+            .map(() => code `${this.schemaVariable}.path`)
+            .orDefault(this.propertyPathToCode(this.path));
+        return [
+            code `${variables.resource}.add(${propertyPath}, ${this.type.toRdfResourceValuesExpression({
+                variables: { ...variables, propertyPath },
+            })}, ${variables.graph});`,
+        ];
+    }
+    toStringInitializer(parameters) {
+        if (!this.display) {
+            return Maybe.empty();
+        }
+        return Maybe.of(code `${literalOf(this.name)}: ${this.type.toStringExpression(parameters)}`);
+    }
+    propertyPathToCode(propertyPath) {
+        switch (propertyPath.termType) {
+            case "AlternativePath":
+            case "SequencePath":
+                return code `{ members: [${joinCode(propertyPath.members.map((member) => this.propertyPathToCode(member)), { on: "," })}], termType: ${literalOf(propertyPath.termType)} }`;
+            case "InversePath":
+            case "OneOrMorePath":
+            case "ZeroOrMorePath":
+            case "ZeroOrOnePath":
+                return code `{ path: ${this.propertyPathToCode(propertyPath.path)}, termType: ${literalOf(propertyPath.termType)} }`;
+            case "NamedNode":
+                return this.rdfjsTermExpression(propertyPath);
+        }
+    }
+}
+__decorate([
+    Memoize()
+], ShaclProperty.prototype, "constructorParameter", null);
+__decorate([
+    Memoize()
+], ShaclProperty.prototype, "declaration", null);
+__decorate([
+    Memoize()
+], ShaclProperty.prototype, "filterProperty", null);
+__decorate([
+    Memoize()
+], ShaclProperty.prototype, "graphqlField", null);
+__decorate([
+    Memoize()
+], ShaclProperty.prototype, "jsonSchema", null);
+__decorate([
+    Memoize()
+], ShaclProperty.prototype, "jsonSignature", null);
+__decorate([
+    Memoize()
+], ShaclProperty.prototype, "schemaVariable", null);
+//# sourceMappingURL=ShaclProperty.js.map

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

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

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

@@ -0,0 +1,5 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_BlankNodeFilter = ({ syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}BlankNodeFilter`, code `\
+interface ${syntheticNamePrefix}BlankNodeFilter {
+}`);
+//# sourceMappingURL=snippets_BlankNodeFilter.js.map

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

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

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

@@ -0,0 +1,6 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_BlankNodeSchema = ({ syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}BlankNodeSchema`, code `\
+interface ${syntheticNamePrefix}BlankNodeSchema {
+  readonly kind: "BlankNode";
+}`);
+//# sourceMappingURL=snippets_BlankNodeSchema.js.map

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

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

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

@@ -0,0 +1,6 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_BooleanFilter = ({ syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}BooleanFilter`, code `\
+interface ${syntheticNamePrefix}BooleanFilter {
+  readonly value?: boolean;
+}`);
+//# sourceMappingURL=snippets_BooleanFilter.js.map

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

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

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

@@ -0,0 +1,8 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_BooleanSchema = ({ imports, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}BooleanSchema`, code `\
+interface ${syntheticNamePrefix}BooleanSchema<BooleanT extends boolean> {
+  readonly hasValues?: readonly ${imports.Literal}[];
+  readonly in?: readonly BooleanT[];
+  readonly kind: "Boolean";
+}`);
+//# sourceMappingURL=snippets_BooleanSchema.js.map

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

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

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

@@ -0,0 +1,7 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_CollectionFilter = ({ syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}CollectionFilter`, code `\
+type ${syntheticNamePrefix}CollectionFilter<ItemFilterT> = ItemFilterT & {
+  readonly ${syntheticNamePrefix}maxCount?: number;
+  readonly ${syntheticNamePrefix}minCount?: number;
+};`);
+//# sourceMappingURL=snippets_CollectionFilter.js.map

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

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

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

@@ -0,0 +1,8 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_CollectionSchema = ({ syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}CollectionSchema`, code `\
+interface ${syntheticNamePrefix}CollectionSchema<ItemSchemaT> {
+  readonly itemType: ItemSchemaT;
+  readonly kind: "List" | "Set";
+  readonly minCount?: number;
+}`);
+//# sourceMappingURL=snippets_CollectionSchema.js.map

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

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

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

@@ -0,0 +1,4 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_ConversionFunction = ({ imports, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}ConversionFunction`, code `\
+type ${syntheticNamePrefix}ConversionFunction<SourceT, TargetT> = (source: SourceT) => ${imports.Either}<Error, TargetT>;`);
+//# sourceMappingURL=snippets_ConversionFunction.js.map

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

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

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

@@ -0,0 +1,10 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_DateFilter = ({ syntheticNamePrefix }) => conditionalOutput(`${syntheticNamePrefix}DateFilter`, code `\
+interface ${syntheticNamePrefix}DateFilter {
+  readonly in?: readonly Date[];
+  readonly maxExclusive?: Date;
+  readonly maxInclusive?: Date;
+  readonly minExclusive?: Date;
+  readonly minInclusive?: Date;
+}`);
+//# sourceMappingURL=snippets_DateFilter.js.map

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

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

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

@@ -0,0 +1,8 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_DateSchema = ({ imports, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}DateSchema`, code `\
+interface ${syntheticNamePrefix}DateSchema {
+  readonly hasValues?: readonly ${imports.Literal}[];
+  readonly in?: readonly Date[];
+  readonly kind: "Date" | "DateTime",
+}`);
+//# sourceMappingURL=snippets_DateSchema.js.map

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

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

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

@@ -0,0 +1,8 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_DefaultValueSchema = ({ imports, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}DefaultValueSchema`, code `\
+interface ${syntheticNamePrefix}DefaultValueSchema<ItemSchemaT> {
+  readonly defaultValue: ${imports.Literal} | ${imports.NamedNode};
+  readonly itemType: ItemSchemaT;
+  readonly kind: "DefaultValue";
+}`);
+//# sourceMappingURL=snippets_DefaultValueSchema.js.map

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

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

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

@@ -0,0 +1,4 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_EqualsFunction = ({ snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}EqualsFunction`, code `\
+export type ${syntheticNamePrefix}EqualsFunction<T> = (left: T, right: T) => ${snippets.EqualsResult};`);
+//# sourceMappingURL=snippets_EqualsFunction.js.map

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

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

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

@@ -0,0 +1,63 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_EqualsResult = ({ imports, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}EqualsResult`, code `\
+export type ${syntheticNamePrefix}EqualsResult = ${imports.Either}<${syntheticNamePrefix}EqualsResult.Unequal, true>;
+
+export namespace ${syntheticNamePrefix}EqualsResult {
+  export const Equal: ${syntheticNamePrefix}EqualsResult = ${imports.Right}(true);
+
+  export function fromBooleanEqualsResult(
+    left: any,
+    right: any,
+    equalsResult: boolean | ${syntheticNamePrefix}EqualsResult,
+  ): ${syntheticNamePrefix}EqualsResult {
+    if (typeof equalsResult !== "boolean") {
+      return equalsResult;
+    }
+
+    if (equalsResult) {
+      return Equal;
+    }
+
+    return ${imports.Left}({ left, right, type: "boolean" });
+  }
+
+  export type Unequal =
+  | {
+    readonly left: {
+      readonly array: readonly any[];
+      readonly element: any;
+      readonly elementIndex: number;
+    };
+    readonly right: {
+      readonly array: readonly any[];
+      readonly unequals: readonly Unequal[];
+    };
+    readonly type: "array-element";
+  }
+  | {
+    readonly left: readonly any[];
+    readonly right: readonly any[];
+    readonly type: "array-length";
+  }
+  | {
+    readonly left: any;
+    readonly right: any;
+    readonly type: "boolean";
+  }
+  | {
+    readonly right: any;
+    readonly type: "left-null";
+  }
+  | {
+    readonly left: any;
+    readonly right: any;
+    readonly propertyName: string;
+    readonly propertyValuesUnequal: Unequal;
+    readonly type: "property";
+  }
+  | {
+    readonly left: any;
+    readonly type: "right-null";
+  };
+}`);
+//# sourceMappingURL=snippets_EqualsResult.js.map

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

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

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

@@ -0,0 +1,10 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_FocusSparqlConstructTriplesFunction = ({ imports, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}FocusSparqlConstructTriplesFunction`, code `\
+type ${syntheticNamePrefix}FocusSparqlConstructTriplesFunction<FilterT> = 
+  (parameters: {
+    filter: FilterT | undefined;
+    focusIdentifier: ${imports.NamedNode} | ${imports.Variable};
+    ignoreRdfType: boolean;
+    variablePrefix: string;
+  }) => readonly ${imports.sparqljs}.Triple[];`);
+//# sourceMappingURL=snippets_FocusSparqlConstructTriplesFunction.js.map

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

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

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

@@ -0,0 +1,11 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_FocusSparqlWherePatternsFunction = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}FocusSparqlWherePatternsFunction`, code `\
+type ${syntheticNamePrefix}FocusSparqlWherePatternsFunction<FilterT> =
+  (parameters: {
+    filter: FilterT | undefined;
+    focusIdentifier: ${imports.NamedNode} | ${imports.Variable};
+    ignoreRdfType: boolean;
+    preferredLanguages: readonly string[] | undefined;
+    variablePrefix: string;
+  }) => readonly ${snippets.SparqlPattern}[];`);
+//# sourceMappingURL=snippets_FocusSparqlWherePatternsFunction.js.map

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

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

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

@@ -0,0 +1,13 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_FromRdfResourceFunction = ({ configuration, imports, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}FromRdfResourceFunction`, code `\
+export type ${syntheticNamePrefix}FromRdfResourceFunction<T> = (
+  resource: ${imports.Resource},
+  options?: {
+    context?: unknown;
+    graph?: Exclude<${imports.Quad_Graph}, ${imports.Variable}>;
+    ignoreRdfType?: boolean;
+    ${configuration.features.has("ObjectSet") ? code `objectSet?: ${syntheticNamePrefix}ObjectSet;` : ""}
+    preferredLanguages?: readonly string[];
+  }
+) => ${imports.Either}<Error, T>`);
+//# sourceMappingURL=snippets_FromRdfResourceFunction.js.map

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

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

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

@@ -0,0 +1,16 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_FromRdfResourceValuesFunction = ({ configuration, imports, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}FromRdfResourceValuesFunction`, code `\
+export type ${syntheticNamePrefix}FromRdfResourceValuesFunction<ValueT, ValueSchemaT> = (
+  resourceValues: ${imports.Resource}.Values,
+  options: {
+    context?: unknown;
+    graph?: Exclude<${imports.Quad_Graph}, ${imports.Variable}>;
+    focusResource: ${imports.Resource};
+    ignoreRdfType?: boolean;
+    ${configuration.features.has("ObjectSet") ? code `objectSet: ${syntheticNamePrefix}ObjectSet;` : ""}
+    preferredLanguages?: readonly string[];
+    propertyPath: ${syntheticNamePrefix}PropertyPath;
+    schema: ValueSchemaT;
+  }
+) => ${imports.Either}<Error, ${imports.Resource}.Values<ValueT>>;`);
+//# sourceMappingURL=snippets_FromRdfResourceValuesFunction.js.map

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

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

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

@@ -0,0 +1,4 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_HashFunction = ({ snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}HashFunction`, code `\
+export type ${syntheticNamePrefix}HashFunction<HasherT extends ${snippets.Hasher}, ValueT> = (hasher: HasherT, value: ValueT) => HasherT;`);
+//# sourceMappingURL=snippets_HashFunction.js.map

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

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

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

@@ -0,0 +1,3 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_Hasher = ({ syntheticNamePrefix }) => conditionalOutput(`${syntheticNamePrefix}Hasher`, code `type ${syntheticNamePrefix}Hasher = { update: (message: string | number[] | ArrayBuffer | Uint8Array) => void; };`);
+//# sourceMappingURL=snippets_Hasher.js.map

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

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

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

@@ -0,0 +1,7 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_IdentifierFilter = ({ imports, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}IdentifierFilter`, code `\
+interface ${syntheticNamePrefix}IdentifierFilter {
+  readonly in?: readonly (${imports.BlankNode} | ${imports.NamedNode})[];
+  readonly type?: "BlankNode" | "NamedNode";
+}`);
+//# sourceMappingURL=snippets_IdentifierFilter.js.map

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

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

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

@@ -0,0 +1,7 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_IdentifierSchema = ({ imports, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}IdentifierSchema`, code `\
+interface ${syntheticNamePrefix}IdentifierSchema {
+  readonly hasValues?: readonly ${imports.NamedNode}[];
+  readonly kind: "Identifier";
+}`);
+//# sourceMappingURL=snippets_IdentifierSchema.js.map

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

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