@shaclmate/compiler 4.0.49 → 4.0.50

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

@@ -1,29 +0,0 @@
-import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-export const snippets_sparqlInstancesOfPattern = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}sparqlInstancesOfPattern`, code `\
-/**
- * A sparqljs.Pattern that's the equivalent of ?subject rdf:type/rdfs:subClassOf* ?rdfType .
- */
-function ${syntheticNamePrefix}sparqlInstancesOfPattern({ rdfType, subject }: { rdfType: ${imports.NamedNode} | ${imports.Variable}, subject: ${imports.sparqljs}.Triple["subject"] }): ${imports.sparqljs}.BgpPattern {
-  return {
-    triples: [
-      {
-        subject,
-        predicate: {
-          items: [
-            ${snippets.RdfVocabularies}.rdf.type,
-            {
-              items: [${snippets.RdfVocabularies}.rdfs.subClassOf],
-              pathType: "*",
-              type: "path",
-            },
-          ],
-          pathType: "/",
-          type: "path",
-        },
-        object: rdfType,
-      },
-    ],
-    type: "bgp",
-  };
-}`);
-//# sourceMappingURL=snippets_sparqlInstancesOfPattern.js.map

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

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

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

@@ -1,59 +0,0 @@
-import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-export const snippets_sparqlPropertyPath = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}sparqlPropertyPath`, code `\
-/**
- * Convert a ${snippets.PropertyPath} to a ${imports.sparqljs}.PropertyPath.
- */  
-function ${syntheticNamePrefix}sparqlPropertyPath(propertyPath: ${snippets.PropertyPath}): ${imports.NamedNode} | ${imports.sparqljs}.PropertyPath {
-  switch (propertyPath.termType) {
-    case "AlternativePath":
-      return {
-        type: "path",
-        pathType: "|",
-        items: propertyPath.members.map(${syntheticNamePrefix}sparqlPropertyPath),
-      };
-
-    case "InversePath":
-      return {
-        type: "path",
-        pathType: "^",
-        items: [${syntheticNamePrefix}sparqlPropertyPath(propertyPath.path)],
-      };
-
-    case "NamedNode":
-      return propertyPath;
-
-    case "OneOrMorePath":
-      return {
-        type: "path",
-        pathType: "+",
-        items: [${syntheticNamePrefix}sparqlPropertyPath(propertyPath.path)],
-      };
-
-    case "SequencePath":
-      return {
-        type: "path",
-        pathType: "/",
-        items: propertyPath.members.map(${syntheticNamePrefix}sparqlPropertyPath),
-      };
-
-    case "ZeroOrMorePath":
-      return {
-        type: "path",
-        pathType: "*",
-        items: [${syntheticNamePrefix}sparqlPropertyPath(propertyPath.path)],
-      };
-
-    case "ZeroOrOnePath":
-      return {
-        type: "path",
-        pathType: "?",
-        items: [${syntheticNamePrefix}sparqlPropertyPath(propertyPath.path)],
-      };
-
-    default: {
-      propertyPath satisfies never;
-      throw new Error(\`unhandled property path termType: \${(propertyPath as any).termType}\`);
-    }
-  }
-}`);
-//# sourceMappingURL=snippets_sparqlPropertyPath.js.map

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

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

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

@@ -1,23 +0,0 @@
-import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-export const snippets_sparqlValueInPattern = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}sparqlValueInPattern`, code `\
-function ${syntheticNamePrefix}sparqlValueInPattern({ lift, valueIn, valueVariable }: { lift?: boolean, valueIn: readonly (bigint | boolean | Date | number | string | ${imports.Literal} | ${imports.NamedNode})[], valueVariable: ${imports.Variable}}): ${snippets.SparqlFilterPattern} {
-  if (valueIn.length === 0) {
-    throw new RangeError("expected valueIn not to be empty");
-  }
-
-  return {
-    expression: {
-      args: [valueVariable, valueIn.map(inValue => {
-        if (typeof inValue !== "object" || inValue instanceof Date) {
-          return ${snippets.literalFactory}.primitive(inValue);
-        }
-        return inValue;
-      })],
-      operator: "in",
-      type: "operation",
-    },
-    lift,
-    type: "filter",
-  };
-}`);
-//# sourceMappingURL=snippets_sparqlValueInPattern.js.map

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

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

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

@@ -1,12 +0,0 @@
-import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-export const snippets_strictEquals = ({ snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}strictEquals`, code `\
-/**
- * Compare two values for strict equality (===), returning an ${snippets.EqualsResult} rather than a boolean.
- */
-function ${syntheticNamePrefix}strictEquals<T extends bigint | boolean | number | string>(
-  left: T,
-  right: T,
-): ${snippets.EqualsResult} {
-  return ${snippets.EqualsResult}.fromBooleanEqualsResult(left, right, left === right);
-}`);
-//# sourceMappingURL=snippets_strictEquals.js.map

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

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

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

@@ -1,6 +0,0 @@
-import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-export const snippets_stringFromRdfResourceValues = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}stringFromRdfResourceValues`, code `\
-function ${syntheticNamePrefix}stringFromRdfResourceValues<StringT extends string>(values: ${imports.Resource}.Values, options: Parameters<${snippets.FromRdfResourceValuesFunction}<StringT, ${snippets.StringSchema}<StringT>>>[1]): ${imports.Either}<Error, ${imports.Resource}.Values<StringT>> {
-  return ${snippets.termLikeFromRdfResourceValues}(values, options).chain(values => values.chainMap(value => options.schema.in ? value.toString(options.schema.in) : value.toString() as ${imports.Either}<Error, StringT>));
-}`);
-//# sourceMappingURL=snippets_stringFromRdfResourceValues.js.map

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

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

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

@@ -1,39 +0,0 @@
-import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-export const snippets_stringSparqlWherePatterns = ({ snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}stringSparqlWherePatterns`, code `\
-const ${syntheticNamePrefix}stringSparqlWherePatterns: ${snippets.ValueSparqlWherePatternsFunction}<${snippets.StringFilter}, ${snippets.StringSchema}<string>> =
-  ({ filter, valueVariable, ...otherParameters }) => {
-    const filterPatterns: ${snippets.SparqlFilterPattern}[] = [];
-
-    if (filter) {
-      if (filter.in !== undefined && filter.in.length > 0) {
-        filterPatterns.push(${snippets.sparqlValueInPattern}({ lift: true, valueVariable, valueIn: filter.in }));
-      }
-
-      if (filter.maxLength !== undefined) {
-        filterPatterns.push({
-          expression: {
-            type: "operation",
-            operator: "<=",
-            args: [{ args: [valueVariable], operator: "strlen", type: "operation" }, ${snippets.literalFactory}.number(filter.maxLength)],
-          },
-          lift: true,
-          type: "filter",
-        });
-      }
-
-      if (filter.minLength !== undefined) {
-        filterPatterns.push({
-          expression: {
-            type: "operation",
-            operator: ">=",
-            args: [{ args: [valueVariable], operator: "strlen", type: "operation" }, ${snippets.literalFactory}.number(filter.minLength)],
-          },
-          lift: true,
-          type: "filter",
-        });
-      }
-    }
-
-    return ${snippets.literalSchemaSparqlPatterns}({ ...otherParameters, filterPatterns, valueVariable });
-  }`);
-//# sourceMappingURL=snippets_stringSparqlWherePatterns.js.map

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

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

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

@@ -1,93 +0,0 @@
-import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-export const snippets_termFilterSparqlPatterns = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}termFilterSparqlPatterns`, code `\
-function ${syntheticNamePrefix}termFilterSparqlPatterns({ filter, valueVariable }: { filter?: ${snippets.TermFilter}<${imports.BlankNode} | ${imports.Literal} | ${imports.NamedNode}>; valueVariable: ${imports.Variable} }): readonly ${snippets.SparqlFilterPattern}[] {
-  if (!filter) {
-    return [];
-  }
-
-  const filterPatterns: ${snippets.SparqlFilterPattern}[] = [];
-
-  if (
-    filter.datatypeIn !== undefined &&
-    filter.datatypeIn.length > 0
-  ) {
-    filterPatterns.push({
-      expression: {
-        type: "operation",
-        operator: "in",
-        args: [
-          { args: [valueVariable], operator: "datatype", type: "operation" },
-          filter.datatypeIn.concat(),
-        ],
-      },
-      lift: true,
-      type: "filter",
-    });
-  }
-
-  if (filter.in !== undefined && filter.in.length > 0) {
-    filterPatterns.push(${snippets.sparqlValueInPattern}({ lift: true, valueVariable, valueIn: filter.in }));
-  }
-
-  if (
-    filter.languageIn !== undefined &&
-    filter.languageIn.length > 0
-  ) {
-    filterPatterns.push({
-      expression: {
-        type: "operation",
-        operator: "in",
-        args: [{ args: [valueVariable], operator: "lang", type: "operation" }, filter.languageIn.map(value => ${imports.dataFactory}.literal(value))]
-      },
-      lift: true,
-      type: "filter",
-    });
-  }
-
-  if (filter.typeIn !== undefined) {
-    const typeInExpressions = filter.typeIn
-      .map((inType) => {
-        switch (inType) {
-          case "BlankNode":
-            return "isBlank";
-          case "Literal":
-            return "isLiteral";
-          case "NamedNode":
-            return "isIRI";
-          default:
-            inType satisfies never;
-            throw new RangeError(inType);
-        }
-      })
-      .map((operator) => ({
-        type: "operation" as const,
-        operator,
-        args: [valueVariable],
-      }));
-
-    switch (typeInExpressions.length) {
-      case 0:
-        break;
-      case 1:
-        filterPatterns.push({
-          expression: typeInExpressions[0],
-          lift: true,
-          type: "filter",
-        });
-        break;
-      default:
-        filterPatterns.push({
-          expression: {
-            type: "operation",
-            operator: "||",
-            args: typeInExpressions,
-          },
-          lift: true,
-          type: "filter",
-        });
-    }
-  }
-
-  return filterPatterns;
-}`);
-//# sourceMappingURL=snippets_termFilterSparqlPatterns.js.map

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

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

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

@@ -1,17 +0,0 @@
-import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-export const snippets_termFromRdfResourceValues = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}termFromRdfResourceValues`, code `\
-function ${syntheticNamePrefix}termFromRdfResourceValues<TermT extends ${imports.BlankNode} | ${imports.Literal} | ${imports.NamedNode}>(values: ${imports.Resource}.Values, options: Parameters<${snippets.FromRdfResourceValuesFunction}<TermT, ${snippets.TermSchema}<TermT>>>[1]): ${imports.Either}<Error, ${imports.Resource}.Values<TermT>> {
-  const { focusResource, propertyPath, schema } = options;
-  return ${snippets.termLikeFromRdfResourceValues}(values, options).chain(values => values.chainMap(value => value.toTerm().chain(term => {
-    if (schema.in && schema.in.length > 0 && !schema.in.some(in_ => in_.equals(term))) {
-      return ${imports.Left}(new ${imports.Resource}.MistypedTermValueError({ actualValue: term, expectedValueType: "Term in", focusResource, propertyPath }));
-    }
-
-    if (!schema.types.some(type => term.termType === type)) {
-      return ${imports.Left}(new ${imports.Resource}.MistypedTermValueError({ actualValue: term, expectedValueType: "Term types", focusResource, propertyPath }));
-    }
-
-    return ${imports.Right}(term as TermT);
-  })));
-}`);
-//# sourceMappingURL=snippets_termFromRdfResourceValues.js.map

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

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

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

@@ -1,60 +0,0 @@
-import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-export const snippets_termLikeFromRdfResourceValues = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}termLikeFromRdfResourceValues`, code `\
-const ${syntheticNamePrefix}termLikeFromRdfResourceValues:
-  ${snippets.FromRdfResourceValuesFunction}<${imports.Resource}.Value, {
-    readonly hasValues?: readonly (${imports.Literal} | ${imports.NamedNode})[];
-    readonly languageIn?: readonly string[];
-  }> = (values, { preferredLanguages, schema: { hasValues, languageIn } }) => {
-    let chain = ${imports.Either}.of<Error, ${imports.Resource}.Values>(values);
-
-    if (hasValues && hasValues.length > 0) {
-      chain = chain.chain(values => ${imports.Either}.sequence(hasValues.map(hasValue => values.find(value => value.term.equals(hasValue)))).map(() => values));
-    }
-
-    if (languageIn && languageIn.length > 0) {
-      chain = chain.chain(values => values.chainMap(value => value.toLiteral().chain(literal =>
-        languageIn.includes(literal.language) ?
-          ${imports.Right}(value) :
-          ${imports.Left}(new ${imports.Resource}.MistypedTermValueError(${{
-    actualValue: code `literal`,
-    expectedValueType: "Literal",
-    focusResource: code `value.focusResource`,
-    propertyPath: code `value.propertyPath`,
-}}))
-      )));
-    }
-
-    if (preferredLanguages && preferredLanguages.length > 0) {
-      chain = chain.chain(values => {
-        const literals: ${imports.Literal}[] = [];
-        const literalValues: ${imports.Resource}.Value[] = [];
-        const nonLiteralValues: ${imports.Resource}.Value[] = [];
-
-        for (const value of values) {
-          const term = value.toTerm().unsafeCoerce();
-          if (term.termType === "Literal") {
-            literals.push(term);
-            literalValues.push(value);
-          } else {
-            nonLiteralValues.push(value);
-          }
-        }
-
-        // Return all literals for the first preferredLanguage, then all literals for the second preferredLanguage, etc.
-        // Within a preferredLanguage the literals may be in any order.
-        const preferredLanguageLiteralValues: ${imports.Resource}.Value[] = [];
-        for (const preferredLanguage of preferredLanguages) {
-          for (let literalI = 0; literalI < literals.length; literalI++) {
-            if (literals[literalI].language === preferredLanguage) {
-              preferredLanguageLiteralValues.push(literalValues[literalI]);
-            }
-          }
-        }
-
-        return ${imports.Right}(${imports.Resource}.Values.fromArray({ focusResource: values.focusResource, propertyPath: values.propertyPath, values: nonLiteralValues.concat(preferredLanguageLiteralValues) }));
-      });
-    }
-
-    return chain;
-  };`);
-//# sourceMappingURL=snippets_termLikeFromRdfResourceValues.js.map

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

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

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

@@ -1,24 +0,0 @@
-import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-export const snippets_termSchemaSparqlPatterns = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}termSchemaSparqlPatterns`, code `\
-function ${syntheticNamePrefix}termSchemaSparqlPatterns({
-  filterPatterns,
-  propertyPatterns,
-  schema,
-  valueVariable
-}: {
-  filterPatterns: readonly ${snippets.SparqlFilterPattern}[],
-  propertyPatterns: readonly ${snippets.SparqlPattern}[];
-  schema: Readonly<{
-    in?: readonly (bigint | boolean | Date | string | number | ${imports.Literal} | ${imports.NamedNode})[];
-  }>,
-  valueVariable: ${imports.Variable};
-}): readonly ${snippets.SparqlPattern}[] {
-  let patterns: ${snippets.SparqlPattern}[] = propertyPatterns.concat();
-
-  if (schema.in && schema.in.length > 0) {
-    patterns.push(${snippets.sparqlValueInPattern}({ valueVariable, valueIn: schema.in }));
-  }
-
-  return patterns.concat(filterPatterns);
-}`);
-//# sourceMappingURL=snippets_termSchemaSparqlPatterns.js.map

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

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

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

@@ -1,5 +0,0 @@
-import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-export const snippets_termSparqlWherePatterns = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}termSparqlWherePatterns`, code `\
-const ${syntheticNamePrefix}termSparqlWherePatterns: ${snippets.ValueSparqlWherePatternsFunction}<${snippets.TermFilter}<${imports.BlankNode} | ${imports.Literal} | ${imports.NamedNode}>, ${snippets.TermSchema}<${imports.BlankNode} | ${imports.Literal} | ${imports.NamedNode}>> =
-  (parameters) => ${snippets.termSchemaSparqlPatterns}({ filterPatterns: ${snippets.termFilterSparqlPatterns}(parameters), ...parameters })`);
-//# sourceMappingURL=snippets_termSparqlWherePatterns.js.map

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

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

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

@@ -1,6 +0,0 @@
-import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-export const snippets_toIsoDateString = ({ syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}toIsoDateString`, code `\
-export function ${syntheticNamePrefix}toIsoDateString(date: Date): string {
-  return date.toISOString().replace(/T.*$/, '')
-}`);
-//# sourceMappingURL=snippets_toIsoDateString.js.map

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

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

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

@@ -1,13 +0,0 @@
-import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-export const snippets_validateArray = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}validateArray`, code `\
-function ${syntheticNamePrefix}validateArray<ItemSchemaT, ItemValueT, Readonly extends boolean>(validateItem: ${snippets.ValidationFunction}<ItemSchemaT, ItemValueT>, _readonly: Readonly) {
-  type EitherR = Readonly extends true ? ReadonlyArray<ItemValueT> : Array<ItemValueT>;
-  return (schema: ${snippets.CollectionSchema}<ItemSchemaT>, valueArray: readonly ItemValueT[]): ${imports.Either}<Error, EitherR> => {
-    if (schema.minCount !== undefined && valueArray.length < schema.minCount) {
-      return ${imports.Left}(new Error(\`value array has length (\${valueArray.length}) less than minCount (\${schema.minCount})\`)) as ${imports.Either}<Error, EitherR>;
-    }
-
-    return ${imports.Either}.sequence(valueArray.map(value => validateItem(schema.itemType, value))) as ${imports.Either}<Error, EitherR>;
-  }
-}`);
-//# sourceMappingURL=snippets_validateArray.js.map

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

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

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

@@ -1,7 +0,0 @@
-import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-export const snippets_validateMaybe = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}validateMaybe`, code `\
-function ${syntheticNamePrefix}validateMaybe<ItemSchemaT, ItemValueT>(validateItem: ${snippets.ValidationFunction}<ItemSchemaT, ItemValueT>) {
-  return (schema: ${snippets.MaybeSchema}<ItemSchemaT>, valueMaybe: ${imports.Maybe}<ItemValueT>): ${imports.Either}<Error, ${imports.Maybe}<ItemValueT>> =>
-    valueMaybe.map(value => validateItem(schema.itemType, value).map(() => valueMaybe)).orDefault(${imports.Either}.of(valueMaybe));
-}`);
-//# sourceMappingURL=snippets_validateMaybe.js.map

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

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

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

@@ -1,9 +0,0 @@
-import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-export const snippets_wrap_FromRdfResourceFunction = ({ configuration, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}wrap_FromRdfResourceFunction`, code `\
-function ${syntheticNamePrefix}wrap_FromRdfResourceFunction<T>(_fromRdfResourceFunction: ${snippets._FromRdfResourceFunction}<T>): ${snippets.FromRdfResourceFunction}<T> {
-  return (resource, options) => {
-    const { context, graph, ignoreRdfType = false, ${configuration.features.has("ObjectSet") ? "objectSet, " : ""}preferredLanguages } = (options ?? {});
-    return _fromRdfResourceFunction(resource, { context, graph, ignoreRdfType, ${configuration.features.has("ObjectSet") ? code `objectSet: objectSet ?? new ${syntheticNamePrefix}RdfjsDatasetObjectSet(resource.dataset), ` : ""}preferredLanguages });
-  };
-}`);
-//# sourceMappingURL=snippets_wrap_FromRdfResourceFunction.js.map

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

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

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

@@ -1,14 +0,0 @@
-import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-export const snippets_wrap_ToRdfResourceFunction = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}wrap_ToRdfResourceFunction`, code `\
-function ${syntheticNamePrefix}wrap_ToRdfResourceFunction<IdentifierT extends ${imports.Resource}.Identifier, ObjectT extends { ${syntheticNamePrefix}identifier: () => IdentifierT }>(_toRdfResourceFunction: ${snippets._ToRdfResourceFunction}<IdentifierT, ObjectT>): ${snippets.ToRdfResourceFunction}<ObjectT, IdentifierT> {
-  return (object, options) => {
-    let { graph, ignoreRdfType = false, resourceSet } = (options ?? {});
-    if (!resourceSet) {
-      resourceSet = new ${imports.ResourceSet}({ dataFactory: ${imports.dataFactory}, dataset: ${imports.datasetFactory}.dataset() });
-    }
-    const resource = resourceSet.resource(object.${syntheticNamePrefix}identifier());
-    _toRdfResourceFunction({ graph, ignoreRdfType, object, resource, resourceSet });
-    return resource;
-  };
-}`);
-//# sourceMappingURL=snippets_wrap_ToRdfResourceFunction.js.map

package/dist/generators/ts/codeEquals.d.ts

@@ -1,3 +0,0 @@
-import type { Code } from "./ts-poet-wrapper.js";
-export declare function codeEquals(left: Code | string, right: Code | string): boolean;
-//# sourceMappingURL=codeEquals.d.ts.map

package/dist/generators/ts/codeEquals.js

@@ -1,7 +0,0 @@
-function codeToString(code) {
-    return typeof code === "string" ? code : code.toString({});
-}
-export function codeEquals(left, right) {
-    return codeToString(left) === codeToString(right);
-}
-//# sourceMappingURL=codeEquals.js.map

package/dist/generators/ts/rdfjsTermExpression.d.ts

@@ -1,11 +0,0 @@
-import type { BlankNode, Literal, NamedNode, Variable } from "@rdfjs/types";
-import type { Logger } from "ts-log";
-import type { Imports } from "./Imports.js";
-import type { Snippets } from "./Snippets.js";
-import { type Code } from "./ts-poet-wrapper.js";
-export declare function rdfjsTermExpression(this: {
-    imports: Imports;
-    logger: Logger;
-    snippets: Snippets;
-}, rdfjsTerm: Omit<BlankNode, "equals"> | Omit<Literal, "equals"> | Omit<NamedNode, "equals"> | Omit<Variable, "equals">): Code;
-//# sourceMappingURL=rdfjsTermExpression.d.ts.map

package/dist/generators/ts/rdfjsTermExpression.js

@@ -1,72 +0,0 @@
-import { rdf, rdfs, xsd } from "@tpluscode/rdf-ns-builders";
-import { code, literalOf } from "./ts-poet-wrapper.js";
-export function rdfjsTermExpression(rdfjsTerm) {
-    switch (rdfjsTerm.termType) {
-        case "BlankNode":
-            return code `${this.imports.dataFactory}.blankNode(${literalOf(rdfjsTerm.value)})`;
-        case "Literal":
-            if (rdfjsTerm.datatype.equals(xsd.string)) {
-                if (rdfjsTerm.language.length === 0) {
-                    return code `${this.imports.dataFactory}.literal(${literalOf(rdfjsTerm.value)})`;
-                }
-                return code `${this.imports.dataFactory}.literal(${literalOf(rdfjsTerm.value)}, ${literalOf(rdfjsTerm.language)})`;
-            }
-            return code `${this.imports.dataFactory}.literal(${literalOf(rdfjsTerm.value)}, ${rdfjsTermExpression.call(this, rdfjsTerm.datatype)})`;
-        case "NamedNode": {
-            if (rdfjsTerm.value.startsWith(rdf[""].value)) {
-                const unqualifiedName = rdfjsTerm.value.substring(rdf[""].value.length);
-                switch (unqualifiedName) {
-                    case "first":
-                    case "nil":
-                    case "rest":
-                    case "subject":
-                    case "type":
-                        return code `${this.snippets.RdfVocabularies}.rdf.${unqualifiedName}`;
-                    default:
-                        this.logger.warn("unrecognized rdf IRI: %s", rdfjsTerm.value);
-                }
-            }
-            else if (rdfjsTerm.value.startsWith(rdfs[""].value)) {
-                const unqualifiedName = rdfjsTerm.value.substring(rdfs[""].value.length);
-                switch (unqualifiedName) {
-                    case "subClassOf":
-                        return code `${this.snippets.RdfVocabularies}.rdfs.${unqualifiedName}`;
-                    default:
-                        this.logger.warn("unrecognized rdfs IRI: %s", rdfjsTerm.value);
-                }
-            }
-            else if (rdfjsTerm.value.startsWith(xsd[""].value)) {
-                const unqualifiedName = rdfjsTerm.value.substring(xsd[""].value.length);
-                switch (unqualifiedName) {
-                    case "boolean":
-                    case "byte":
-                    case "float":
-                    case "date":
-                    case "dateTime":
-                    case "decimal":
-                    case "double":
-                    case "int":
-                    case "integer":
-                    case "long":
-                    case "negativeInteger":
-                    case "nonNegativeInteger":
-                    case "nonPositiveInteger":
-                    case "positiveInteger":
-                    case "short":
-                    case "string":
-                    case "unsignedByte":
-                    case "unsignedInt":
-                    case "unsignedLong":
-                    case "unsignedShort":
-                        return code `${this.snippets.RdfVocabularies}.xsd.${unqualifiedName}`;
-                    default:
-                        this.logger.warn("unrecognized xsd IRI: %s", rdfjsTerm.value);
-                }
-            }
-            return code `${this.imports.dataFactory}.namedNode(${literalOf(rdfjsTerm.value)})`;
-        }
-        case "Variable":
-            return code `${this.imports.dataFactory}.variable!(${literalOf(rdfjsTerm.value)})`;
-    }
-}
-//# sourceMappingURL=rdfjsTermExpression.js.map

package/dist/generators/ts/singleEntryRecord.d.ts

@@ -1,2 +0,0 @@
-export declare function singleEntryRecord<T>(key: string, value: T): Record<string, T>;
-//# sourceMappingURL=singleEntryRecord.d.ts.map

package/dist/generators/ts/singleEntryRecord.js

@@ -1,6 +0,0 @@
-export function singleEntryRecord(key, value) {
-    const record = {};
-    record[key] = value;
-    return record;
-}
-//# sourceMappingURL=singleEntryRecord.js.map

package/dist/generators/ts/ts-poet-wrapper.d.ts

@@ -1,5 +0,0 @@
-/**
- * Wrapper around ts-poet, enabled during debugging to throw errors on Code.toString.
- */
-export * from "ts-poet";
-//# sourceMappingURL=ts-poet-wrapper.d.ts.map