@shaclmate/compiler 4.0.48 → 4.0.50

package/dist/generators/ts/RdfjsDatasetObjectSetType.js

@@ -1,323 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

@@ -1,32 +0,0 @@
-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

@@ -1,132 +0,0 @@
-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

@@ -1,3 +0,0 @@
-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

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

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

@@ -1,16 +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 { 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

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