@shaclmate/compiler 4.0.50 → 4.0.52

package/dist/generators/ts/RdfjsDatasetObjectSetType.js

@@ -0,0 +1,323 @@
+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 { Memoize } from "typescript-memoize";
+import { AbstractObjectSetType } from "./AbstractObjectSetType.js";
+import { code, joinCode } from "./ts-poet-wrapper.js";
+export class RdfjsDatasetObjectSetType extends AbstractObjectSetType {
+    get declaration() {
+        const syntheticNamePrefix = this.configuration.syntheticNamePrefix;
+        const namedObjectTypeType = code `\
+{
+  filter: (filter: ObjectFilterT, value: ObjectT) => boolean;
+  fromRdfResource: ${this.reusables.snippets.FromRdfResourceFunction}<ObjectT>;
+  fromRdfTypes: readonly ${this.reusables.imports.NamedNode}[]
+}`;
+        const parameters = {
+            query: `query?: ${syntheticNamePrefix}ObjectSet.Query<ObjectFilterT, ObjectIdentifierT>`,
+        };
+        const typeParameters = {
+            ObjectT: code `ObjectT extends { readonly $identifier: () => ObjectIdentifierT }`,
+            ObjectFilterT: code `ObjectFilterT`,
+            ObjectIdentifierT: code `ObjectIdentifierT extends ${this.reusables.imports.BlankNode} | ${this.reusables.imports.NamedNode}`,
+        };
+        return code `\
+export class ${syntheticNamePrefix}RdfjsDatasetObjectSet implements ${syntheticNamePrefix}ObjectSet {
+  readonly #dataset: ${this.reusables.imports.DatasetCore} | (() => ${this.reusables.imports.DatasetCore});
+  readonly #graph?: Exclude<${this.reusables.imports.Quad_Graph}, ${this.reusables.imports.Variable}>;
+
+  constructor(dataset: ${this.reusables.imports.DatasetCore} | (() => ${this.reusables.imports.DatasetCore}), options?: { graph?: Exclude<${this.reusables.imports.Quad_Graph}, ${this.reusables.imports.Variable}> }) {
+    this.#dataset = dataset;
+    this.#graph = options?.graph;
+  }
+
+  protected ${syntheticNamePrefix}dataset(): DatasetCore {
+    if (typeof this.#dataset === "object") {
+      return this.#dataset;
+    }
+    return this.#dataset();
+  }
+
+  protected ${syntheticNamePrefix}resourceSet(): ${this.reusables.imports.ResourceSet} {
+    return new ${this.reusables.imports.ResourceSet}({ dataFactory: ${this.reusables.imports.dataFactory}, dataset: this.${syntheticNamePrefix}dataset() });
+  }
+
+  ${joinCode([
+            ...[...this.namedObjectTypes, ...this.namedObjectUnionTypes].flatMap((namedObjectType) => {
+                const methodSignatures = this.methodSignatures(namedObjectType);
+                const delegatingMethods = [
+                    // object
+                    code `\
+async ${methodSignatures.object.name}(${methodSignatures.object.parameters}): ${methodSignatures.object.returnType} {
+  return this.${methodSignatures.object.name}Sync(identifier, options);
+}`,
+                    // objectSync
+                    code `\
+${methodSignatures.object.name}Sync(${methodSignatures.object.parameters}): ${this.reusables.imports.Either}<Error, ${namedObjectType.expression}> {
+  return this.${methodSignatures.objects.name}Sync({ identifiers: [identifier], preferredLanguages: options?.preferredLanguages }).map(objects => objects[0]);
+}`,
+                    // objectCount
+                    code `\
+async ${methodSignatures.objectCount.name}(${methodSignatures.objectCount.parameters}): ${methodSignatures.objectCount.returnType} {
+  return this.${methodSignatures.objectCount.name}Sync(query);
+}`,
+                    // objectCountSync
+                    code `\
+${methodSignatures.objectCount.name}Sync(${methodSignatures.objectCount.parameters}): ${this.reusables.imports.Either}<Error, number> {
+  return this.${methodSignatures.objects.name}Sync(query).map(objects => objects.length);
+}`,
+                    // objectIdentifiers
+                    code `\
+async ${methodSignatures.objectIdentifiers.name}(${methodSignatures.objectIdentifiers.parameters}): ${methodSignatures.objectIdentifiers.returnType} {
+  return this.${methodSignatures.objectIdentifiers.name}Sync(query);
+}`,
+                    // objectIdentifiersSync
+                    code `\
+${methodSignatures.objectIdentifiers.name}Sync(${methodSignatures.objectIdentifiers.parameters}): ${this.reusables.imports.Either}<Error, readonly ${namedObjectType.identifierTypeAlias}[]> {
+  return this.${methodSignatures.objects.name}Sync(query).map(objects => objects.map(object => object.${syntheticNamePrefix}identifier()));
+}`,
+                    // objects
+                    code `\
+async ${methodSignatures.objects.name}(${methodSignatures.objects.parameters}): ${methodSignatures.objects.returnType} {
+  return this.${methodSignatures.objects.name}Sync(query);
+}`,
+                    // objectsSync has per-object type logic, not just forwarding
+                ];
+                const runtimeObjectType = (filterFunction, namedObjectType) => {
+                    return code `{ filter: ${filterFunction}, fromRdfResource: ${namedObjectType.expression}.fromRdfResource, fromRdfTypes: ${namedObjectType.fromRdfTypeVariable.map((fromRdfTypeVariable) => code `[${fromRdfTypeVariable}]`).orDefault(code `[]`)} }`;
+                };
+                switch (namedObjectType.kind) {
+                    case "Object": {
+                        return delegatingMethods.concat(code `\
+${methodSignatures.objects.name}Sync(${methodSignatures.objects.parameters}): ${this.reusables.imports.Either}<Error, readonly ${namedObjectType.expression}[]> {
+  return this.#objectsSync<${namedObjectType.expression}, ${namedObjectType.filterType}, ${namedObjectType.identifierTypeAlias}>(${runtimeObjectType(namedObjectType.filterFunction, namedObjectType)}, query);
+}`);
+                    }
+                    case "ObjectUnion":
+                        return delegatingMethods.concat(code `\
+${methodSignatures.objects.name}Sync(${methodSignatures.objects.parameters}): ${this.reusables.imports.Either}<Error, readonly ${namedObjectType.expression}[]> {
+  return this.#objectUnionsSync<${namedObjectType.expression}, ${namedObjectType.filterType}, ${namedObjectType.identifierTypeAlias}>([
+    ${joinCode(namedObjectType.members.map((member) => runtimeObjectType(namedObjectType.filterFunction, member.type)), { on: ", " })}
+  ], query);
+}`);
+                    default:
+                        namedObjectType;
+                        return [];
+                }
+            }),
+            ...(this.namedObjectTypes.length > 0
+                ? [
+                    code `\
+#objectsSync<${typeParameters.ObjectT}, ${typeParameters.ObjectFilterT}, ${typeParameters.ObjectIdentifierT}>(namedObjectType: ${namedObjectTypeType}, ${parameters.query}): ${this.reusables.imports.Either}<Error, readonly ObjectT[]> {
+  const graph = query?.graph ?? this.#graph;
+
+  const limit = query?.limit ?? Number.MAX_SAFE_INTEGER;
+  if (limit <= 0) { return ${this.reusables.imports.Right}([]); }
+
+  let offset = query?.offset ?? 0;
+  if (offset < 0) { offset = 0; }
+
+  const fromRdfResourceOptions: Parameters<${this.reusables.snippets.FromRdfResourceFunction}<ObjectT>>[1] = { graph, objectSet: this, preferredLanguages: query?.preferredLanguages };
+
+  let resources: { object?: ObjectT, resource: ${this.reusables.imports.Resource} }[];
+  const resourceSet = this.${syntheticNamePrefix}resourceSet(); // Access once, in case it's instantiated lazily
+  let sortResources: boolean;
+  if (query?.identifiers) {
+    resources = query.identifiers.map(identifier => ({ resource: resourceSet.resource(identifier) }));
+    sortResources = false;
+  } else if (namedObjectType.fromRdfTypes.length > 0) {
+    const identifierSet = new ${this.reusables.snippets.IdentifierSet}();
+    resources = [];
+    sortResources = true;
+    for (const fromRdfType of namedObjectType.fromRdfTypes) {
+      for (const resource of resourceSet.instancesOf(fromRdfType, { graph })) {
+        if (!identifierSet.has(resource.identifier)) {
+          identifierSet.add(resource.identifier);
+          resources.push({ resource });
+        }
+      }
+    }
+  } else {
+    const identifierSet = new ${this.reusables.snippets.IdentifierSet}();
+    resources = [];
+    sortResources = true;
+    for (const quad of resourceSet.dataset) {
+      if (graph && !quad.graph.equals(graph)) {
+        continue;
+      }
+
+      switch (quad.subject.termType) {
+        case "BlankNode":
+        case "NamedNode":
+          break;
+        default:
+          continue;
+      }
+
+      if (identifierSet.has(quad.subject)) {
+        continue;
+      }
+      identifierSet.add(quad.subject);
+      const resource = resourceSet.resource(quad.subject);
+      // Eagerly eliminate the majority of resources that won't match the object type
+      namedObjectType.fromRdfResource(resource, fromRdfResourceOptions).ifRight(object => {
+        resources.push({ object, resource });
+      });
+    }
+  }
+
+  if (sortResources) {
+    // Sort resources by identifier so limit and offset are deterministic
+    resources.sort((left, right) => left.resource.identifier.value.localeCompare(right.resource.identifier.value));
+  }
+
+  let objectI = 0;
+  const objects: ObjectT[] = [];
+  for (let { object, resource } of resources) {
+    if (!object) {
+      const objectEither = namedObjectType.fromRdfResource(resource, fromRdfResourceOptions);
+      if (objectEither.isLeft()) {
+        return objectEither;
+      }
+      object = objectEither.unsafeCoerce();
+    }
+
+    if (query?.filter && !namedObjectType.filter(query.filter, object)) {
+      continue;
+    }
+
+    if (objectI++ >= offset) {
+      objects.push(object);
+      if (objects.length === limit) {
+        return ${this.reusables.imports.Right}(objects);
+      }
+    }
+  }
+  return ${this.reusables.imports.Right}(objects);
+  }`,
+                ]
+                : []),
+            ...(this.namedObjectUnionTypes.length > 0
+                ? [
+                    code `\
+#objectUnionsSync<${typeParameters.ObjectT}, ${typeParameters.ObjectFilterT}, ${typeParameters.ObjectIdentifierT}>(namedObjectTypes: readonly ${namedObjectTypeType}[], ${parameters.query}): ${this.reusables.imports.Either}<Error, readonly ObjectT[]> {
+  const graph = query?.graph ?? this.#graph;
+
+  const limit = query?.limit ?? Number.MAX_SAFE_INTEGER;
+  if (limit <= 0) { return ${this.reusables.imports.Right}([]); }
+
+  let offset = query?.offset ?? 0;
+  if (offset < 0) { offset = 0; }
+
+  const fromRdfResourceOptions: Parameters<${this.reusables.snippets.FromRdfResourceFunction}<ObjectT>>[1] = { graph, objectSet: this, preferredLanguages: query?.preferredLanguages };
+
+  let resources: { object?: ObjectT, namedObjectType?: ${namedObjectTypeType}, resource: ${this.reusables.imports.Resource} }[];
+  const resourceSet = this.${syntheticNamePrefix}resourceSet(); // Access once, in case it's instantiated lazily
+  let sortResources: boolean;
+  if (query?.identifiers) {
+    resources = query.identifiers.map(identifier => ({ resource: resourceSet.resource(identifier) }));
+    sortResources = false;
+  } else if (namedObjectTypes.every(namedObjectType => namedObjectType.fromRdfTypes.length > 0)) {
+    const identifierSet = new ${this.reusables.snippets.IdentifierSet}();
+    resources = [];
+    sortResources = true;
+    for (const namedObjectType of namedObjectTypes) {
+      for (const fromRdfType of namedObjectType.fromRdfTypes) {
+        for (const resource of resourceSet.instancesOf(fromRdfType, { graph })) {
+          if (!identifierSet.has(resource.identifier)) {
+            identifierSet.add(resource.identifier);
+            resources.push({ namedObjectType, resource });
+          }
+        }
+      }
+    }
+  } else {
+    const identifierSet = new ${this.reusables.snippets.IdentifierSet}();
+    resources = [];
+    sortResources = true;
+    for (const quad of resourceSet.dataset) {
+      if (graph && !quad.graph.equals(graph)) {
+        continue;
+      }
+    
+      switch (quad.subject.termType) {
+        case "BlankNode":
+        case "NamedNode":
+          break;
+        default:
+          continue;
+      }
+
+      if (identifierSet.has(quad.subject)) {
+        continue;
+      }
+      identifierSet.add(quad.subject);
+      // Eagerly eliminate the majority of resources that won't match the object types
+      const resource = resourceSet.resource(quad.subject);
+      for (const namedObjectType of namedObjectTypes) {
+        if (namedObjectType.fromRdfResource(resource, fromRdfResourceOptions).ifRight(object => {
+          resources.push({ object, namedObjectType, resource });
+        }).isRight()) {
+          break;
+        }
+      }
+    }
+  }
+
+  if (sortResources) {
+    // Sort resources by identifier so limit and offset are deterministic
+    resources.sort((left, right) => left.resource.identifier.value.localeCompare(right.resource.identifier.value));
+  }
+
+  let objectI = 0;
+  const objects: ObjectT[] = [];
+  for (let { object, namedObjectType, resource } of resources) {
+    if (!object) {
+      let objectEither: ${this.reusables.imports.Either}<Error, ObjectT>;
+      if (namedObjectType) {
+        objectEither = namedObjectType.fromRdfResource(resource, fromRdfResourceOptions);
+      } else {
+        objectEither = ${this.reusables.imports.Left}(new Error("no object types"));
+        for (const tryObjectType of namedObjectTypes) {
+          objectEither = tryObjectType.fromRdfResource(resource, fromRdfResourceOptions);
+          if (objectEither.isRight()) {
+            namedObjectType = tryObjectType;
+            break;
+          }
+        }
+      }
+      if (objectEither.isLeft()) {
+        return objectEither;
+      }
+      object = objectEither.unsafeCoerce();
+    }
+    if (!namedObjectType) {
+      throw new Error("namedObjectType should be set here");
+    }
+
+    if (query?.filter && !namedObjectType.filter(query.filter, object)) {
+      continue;
+    }
+
+    if (objectI++ >= offset) {
+      objects.push(object);
+      if (objects.length === limit) {
+        return ${this.reusables.imports.Right}(objects);
+      }
+    }
+  }
+  return ${this.reusables.imports.Right}(objects);
+}`,
+                ]
+                : []),
+        ], { on: "\n\n" })}
+}`;
+    }
+}
+__decorate([
+    Memoize()
+], RdfjsDatasetObjectSetType.prototype, "declaration", null);
+//# sourceMappingURL=RdfjsDatasetObjectSetType.js.map

package/dist/generators/ts/Reusables.d.ts

@@ -0,0 +1,13 @@
+import type { Logger } from "ts-log";
+import { Imports } from "./Imports.js";
+import { Snippets } from "./Snippets.js";
+import type { TsGenerator } from "./TsGenerator.js";
+export declare class Reusables {
+    readonly imports: Imports;
+    readonly snippets: Snippets;
+    constructor({ configuration, logger, }: {
+        configuration: TsGenerator.Configuration;
+        logger: Logger;
+    });
+}
+//# sourceMappingURL=Reusables.d.ts.map

package/dist/generators/ts/Reusables.js

@@ -0,0 +1,15 @@
+import { Imports } from "./Imports.js";
+import { Snippets } from "./Snippets.js";
+export class Reusables {
+    imports;
+    snippets;
+    constructor({ configuration, logger, }) {
+        this.imports = new Imports();
+        this.snippets = new Snippets({
+            configuration,
+            imports: this.imports,
+            logger,
+        });
+    }
+}
+//# sourceMappingURL=Reusables.js.map

package/dist/generators/ts/SetType.d.ts

@@ -0,0 +1,32 @@
+import { Maybe } from "purify-ts";
+import { AbstractCollectionType } from "./AbstractCollectionType.js";
+import type { AbstractContainerType } from "./AbstractContainerType.js";
+import { type Code } from "./ts-poet-wrapper.js";
+export declare class SetType<ItemTypeT extends SetType.ItemType> extends AbstractCollectionType<ItemTypeT> {
+    readonly graphqlArgs: AbstractCollectionType<ItemTypeT>["graphqlArgs"];
+    readonly jsTypes: readonly [{
+        readonly instanceof: "Array";
+        readonly typeof: "object";
+    }];
+    readonly kind = "Set";
+    readonly minCount: bigint;
+    constructor({ minCount, ...superParameters }: {
+        minCount: bigint;
+    } & ConstructorParameters<typeof AbstractCollectionType<ItemTypeT>>[0]);
+    get conversionFunction(): Maybe<AbstractCollectionType.ConversionFunction>;
+    get fromRdfResourceValuesFunction(): Code;
+    get toRdfResourceValueTypes(): AbstractCollectionType<ItemTypeT>["toRdfResourceValueTypes"];
+    get valueSparqlConstructTriplesFunction(): Code;
+    get valueSparqlWherePatternsFunction(): Code;
+    protected get schemaInitializers(): readonly Code[];
+    fromJsonExpression({ variables, }: Parameters<AbstractContainerType<ItemTypeT>["fromJsonExpression"]>[0]): Code;
+    jsonSchema(parameters: Parameters<AbstractContainerType<ItemTypeT>["jsonSchema"]>[0]): Code;
+    jsonType(): AbstractCollectionType.JsonType;
+    toRdfResourceValuesExpression({ variables, }: Parameters<AbstractCollectionType<ItemTypeT>["toRdfResourceValuesExpression"]>[0]): Code;
+    toStringExpression({ variables, }: Parameters<AbstractCollectionType<ItemTypeT>["toStringExpression"]>[0]): Code;
+}
+export declare namespace SetType {
+    type ItemType = AbstractCollectionType.ItemType;
+    const isItemType: typeof AbstractContainerType.isItemType;
+}
+//# sourceMappingURL=SetType.d.ts.map

package/dist/generators/ts/SetType.js

@@ -0,0 +1,132 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { Maybe } from "purify-ts";
+import { invariant } from "ts-invariant";
+import { Memoize } from "typescript-memoize";
+import { AbstractCollectionType } from "./AbstractCollectionType.js";
+import { code, joinCode, literalOf } from "./ts-poet-wrapper.js";
+export class SetType extends AbstractCollectionType {
+    graphqlArgs = Maybe.empty();
+    jsTypes = [
+        { instanceof: "Array", typeof: "object" },
+    ];
+    kind = "Set";
+    minCount;
+    constructor({ minCount, ...superParameters }) {
+        super(superParameters);
+        this.minCount = minCount;
+        invariant(this.minCount >= 0n);
+        if (this._mutable) {
+            invariant(this.minCount === 0n);
+        }
+    }
+    get conversionFunction() {
+        const itemConversionFunction = this.itemType.conversionFunction.orDefault(this.itemConversionFunctionDefault);
+        let conversionFunction;
+        const sourceTypes = [];
+        if (itemConversionFunction.sourceTypes.some((sourceType) => sourceType.jsType.typeof === "object" &&
+            sourceType.jsType.instanceof === "Array")) {
+            conversionFunction = this.reusables.snippets.convertToArraySet;
+        }
+        else {
+            conversionFunction = this.reusables.snippets.convertToScalarSet;
+            // Convert from a single item
+            sourceTypes.push(...itemConversionFunction.sourceTypes);
+        }
+        // Convert from an array of items
+        sourceTypes.push({
+            expression: code `readonly (${joinCode(itemConversionFunction.sourceTypes.map((itemSourceType) => code `${itemSourceType.expression}`), { on: " | " })})[]`,
+            jsType: { instanceof: "Array", typeof: "object" },
+        });
+        // Convert from undefined to an empty array
+        if (this.minCount === 0n) {
+            sourceTypes.push({
+                expression: code `undefined`,
+                jsType: { typeof: "undefined" },
+            });
+        }
+        return Maybe.of({
+            code: code `${conversionFunction}(${itemConversionFunction.code}, ${literalOf(!this._mutable)})`,
+            sourceTypes,
+        });
+    }
+    get fromRdfResourceValuesFunction() {
+        return code `${this._mutable ? this.reusables.snippets.mutableSetFromRdfResourceValues : this.reusables.snippets.setFromRdfResourceValues}<${this.itemType.expression}, ${this.itemType.schemaType}>(${this.itemType.fromRdfResourceValuesFunction})`;
+    }
+    get toRdfResourceValueTypes() {
+        return this.itemType.toRdfResourceValueTypes;
+    }
+    get valueSparqlConstructTriplesFunction() {
+        return code `${this.reusables.snippets.setSparqlConstructTriples}<${this.itemType.filterType}, ${this.itemType.schemaType}>(${this.itemType.valueSparqlConstructTriplesFunction})`;
+    }
+    get valueSparqlWherePatternsFunction() {
+        return code `${this.reusables.snippets.setSparqlWherePatterns}<${this.itemType.filterType}, ${this.itemType.schemaType}>(${this.itemType.valueSparqlWherePatternsFunction})`;
+    }
+    get schemaInitializers() {
+        let schemaInitializers = super.schemaInitializers;
+        if (this.minCount > 0n) {
+            schemaInitializers = schemaInitializers.concat(code `minCount: ${Number(this.minCount)}`);
+        }
+        return schemaInitializers;
+    }
+    fromJsonExpression({ variables, }) {
+        let expression = variables.value;
+        if (this.minCount === 0n) {
+            expression = code `(${expression} ?? [])`;
+        }
+        return code `${this.reusables.imports.Either}.sequence<Error, ${this.itemType.expression}>(${expression}.map(item => (${this.itemType.fromJsonExpression({
+            variables: { value: code `item` },
+        })})))`;
+    }
+    jsonSchema(parameters) {
+        let schema = code `${this.itemType.jsonSchema(parameters)}.array()`;
+        if (this.minCount > 0n) {
+            schema = code `${schema}.nonempty().min(${this.minCount})`;
+        }
+        else {
+            schema = code `${schema}.optional()`;
+        }
+        if (!this._mutable) {
+            schema = code `${schema}.readonly()`;
+        }
+        return schema;
+    }
+    jsonType() {
+        const name = code `${!this.mutable ? "readonly " : ""}(${this.itemType.jsonType().expression})[]`;
+        if (this.minCount === 0n) {
+            return new AbstractCollectionType.JsonType(name, { optional: true });
+        }
+        return new AbstractCollectionType.JsonType(name);
+    }
+    toRdfResourceValuesExpression({ variables, }) {
+        return code `${variables.value}.flatMap((item) => ${this.itemType.toRdfResourceValuesExpression({
+            variables: { ...variables, value: code `item` },
+        })})`;
+    }
+    toStringExpression({ variables, }) {
+        return code `(${variables.value}.length > 0 ? \`[\${${variables.value}.map(item => (${this.itemType.toStringExpression({ variables: { value: code `item` } })}))}]\` : undefined)`;
+    }
+}
+__decorate([
+    Memoize()
+], SetType.prototype, "conversionFunction", null);
+__decorate([
+    Memoize()
+], SetType.prototype, "fromRdfResourceValuesFunction", null);
+__decorate([
+    Memoize()
+], SetType.prototype, "valueSparqlConstructTriplesFunction", null);
+__decorate([
+    Memoize()
+], SetType.prototype, "valueSparqlWherePatternsFunction", null);
+__decorate([
+    Memoize()
+], SetType.prototype, "jsonType", null);
+(function (SetType) {
+    SetType.isItemType = AbstractCollectionType.isItemType;
+})(SetType || (SetType = {}));
+//# sourceMappingURL=SetType.js.map

package/dist/generators/ts/Snippet.d.ts

@@ -0,0 +1,3 @@
+import type { conditionalOutput } from "./ts-poet-wrapper.js";
+export type Snippet = ReturnType<typeof conditionalOutput>;
+//# sourceMappingURL=Snippet.d.ts.map

package/dist/generators/ts/Snippet.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=Snippet.js.map

package/dist/generators/ts/SnippetFactory.d.ts

@@ -0,0 +1,16 @@
+import type { BlankNode, Literal, NamedNode, Variable } from "@rdfjs/types";
+import type { Logger } from "ts-log";
+import type { Imports } from "./Imports.js";
+import type { Snippet } from "./Snippet.js";
+import type { Snippets } from "./Snippets.js";
+import type { TsGenerator } from "./TsGenerator.js";
+import type { Code } from "./ts-poet-wrapper.js";
+export type SnippetFactory = (parameters: {
+    configuration: TsGenerator.Configuration;
+    imports: Imports;
+    logger: Logger;
+    rdfjsTermExpression: (rdfjsTerm: Omit<BlankNode, "equals"> | Omit<Literal, "equals"> | Omit<NamedNode, "equals"> | Omit<Variable, "equals">) => Code;
+    snippets: Snippets;
+    syntheticNamePrefix: string;
+}) => Snippet;
+//# sourceMappingURL=SnippetFactory.d.ts.map

package/dist/generators/ts/SnippetFactory.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=SnippetFactory.js.map