@happyvertical/smrt-tags 0.30.0

package/dist/index.js

@@ -0,0 +1,739 @@
+import { ObjectRegistry, field, smrt, SmrtHierarchical, SmrtObject, SmrtCollection } from "@happyvertical/smrt-core";
+import { tenantId, TenantScoped } from "@happyvertical/smrt-tenancy";
+import { calculateLevel, generateUniqueSlug, hasCircularReference, sanitizeSlug, validateSlug } from "./utils.js";
+ObjectRegistry.registerPackageManifest(
+  new URL("./manifest.json", import.meta.url)
+);
+var __defProp$1 = Object.defineProperty;
+var __getOwnPropDesc$1 = Object.getOwnPropertyDescriptor;
+var __decorateClass$1 = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$1(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp$1(target, key, result);
+  return result;
+};
+let Tag = class extends SmrtHierarchical {
+  // id: UUID (auto-generated by SmrtObject)
+  _slug = "";
+  // Unique identifier
+  _context = "global";
+  // Namespace/grouping
+  // Override SmrtObject accessors
+  get slug() {
+    return this._slug;
+  }
+  set slug(value) {
+    this._slug = value;
+  }
+  get context() {
+    return this._context;
+  }
+  set context(value) {
+    this._context = value;
+  }
+  name = "";
+  // Display name
+  // parentId inherited from SmrtHierarchical (UUID, nullable). Stores the
+  // parent Tag's id (not its slug) — Tag's slug+context natural key remains
+  // the public identifier on TagCollection's API, but the FK is now UUID
+  // for consistency with Place / Event / Account / Zone.
+  level = 0;
+  // Hierarchy depth (0 = root)
+  description = "";
+  // Optional description
+  metadata = "";
+  tenantId = null;
+  // Timestamps
+  createdAt = /* @__PURE__ */ new Date();
+  updatedAt = /* @__PURE__ */ new Date();
+  constructor(options = {}) {
+    super(options);
+    if (options.name) this.name = options.name;
+    if (options.parentId !== void 0)
+      this.parentId = options.parentId ?? null;
+    if (options.slug) this._slug = options.slug;
+    if (options.context !== void 0) this._context = options.context;
+    if (options.level !== void 0) this.level = options.level;
+    if (options.description !== void 0)
+      this.description = options.description;
+    if (options.metadata !== void 0) {
+      if (typeof options.metadata === "string") {
+        this.metadata = options.metadata;
+      } else {
+        this.metadata = JSON.stringify(options.metadata);
+      }
+    }
+  }
+  /**
+   * Get metadata as parsed object
+   *
+   * @returns Parsed metadata object or empty object if no metadata
+   */
+  getMetadata() {
+    const metadataValue = String(this.metadata || "");
+    if (!metadataValue) return {};
+    try {
+      return JSON.parse(metadataValue);
+    } catch {
+      return {};
+    }
+  }
+  /**
+   * Set metadata from object
+   *
+   * @param data - Metadata object to store
+   */
+  setMetadata(data) {
+    this.metadata = JSON.stringify(data);
+  }
+  /**
+   * Update metadata by merging with existing values
+   *
+   * @param updates - Partial metadata to merge
+   */
+  updateMetadata(updates) {
+    const current = this.getMetadata();
+    this.setMetadata({ ...current, ...updates });
+  }
+  // Hierarchy traversal (getParent / getChildren / getAncestors /
+  // getDescendants / getHierarchy / moveTo) provided by SmrtHierarchical
+  // against the inherited UUID `parentId`. TagCollection wraps these in
+  // slug-friendly methods (moveTag / mergeTag / getChildren etc.) so the
+  // existing public API surface keeps working for callers that prefer
+  // slug references.
+  /**
+   * Convenience method for slug-based lookup
+   *
+   * @param slug - The slug to search for
+   * @param context - Optional context filter
+   * @returns Tag instance or null if not found
+   */
+  static async getBySlug(_slug, _context) {
+    return null;
+  }
+  /**
+   * Get root tags (no parent) for a context
+   *
+   * @param context - The context to filter by
+   * @returns Array of root tags
+   */
+  static async getRootTags(_context = "global") {
+    return [];
+  }
+};
+__decorateClass$1([
+  field({ required: true })
+], Tag.prototype, "name", 2);
+__decorateClass$1([
+  tenantId({ nullable: true })
+], Tag.prototype, "tenantId", 2);
+Tag = __decorateClass$1([
+  TenantScoped({ mode: "optional" }),
+  smrt({
+    tableStrategy: "sti",
+    api: { include: ["list", "get", "create", "update", "delete"] },
+    mcp: { include: ["list", "get", "create", "update"] },
+    cli: true
+  })
+], Tag);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+let TagAlias = class extends SmrtObject {
+  // id: UUID (auto-generated by SmrtObject)
+  tagSlug = "";
+  alias = "";
+  // Alternative name or translation
+  language = "";
+  // ISO 639-1 language code (nullable)
+  _context = "";
+  // Optional context scoping (nullable)
+  // Override SmrtObject accessor
+  get context() {
+    return this._context;
+  }
+  set context(value) {
+    this._context = value;
+  }
+  tenantId = null;
+  // Timestamps
+  createdAt = /* @__PURE__ */ new Date();
+  constructor(options = {}) {
+    super(options);
+    if (options.tagSlug !== void 0) this.tagSlug = options.tagSlug;
+    if (options.alias) this.alias = options.alias;
+    if (options.language !== void 0) this.language = options.language;
+    if (options.context !== void 0) this._context = options.context;
+  }
+  /**
+   * Get the tag this alias belongs to
+   *
+   * @returns Tag instance or null if not found
+   */
+  async getTag() {
+    const { TagCollection: TagCollection2 } = await Promise.resolve().then(() => tags);
+    const collection = await TagCollection2.create(this.options);
+    return await collection.get({ slug: this.tagSlug });
+  }
+  /**
+   * Search tags by alias
+   *
+   * @param alias - The alias to search for
+   * @param language - Optional language filter
+   * @returns Array of matching tags
+   */
+  static async searchByAlias(_alias, _language) {
+    return [];
+  }
+  /**
+   * Get all aliases for a tag
+   *
+   * @param tagSlug - The tag slug to get aliases for
+   * @returns Array of TagAlias instances
+   */
+  static async getAliasesForTag(_tagSlug) {
+    return [];
+  }
+};
+__decorateClass([
+  field({ required: true })
+], TagAlias.prototype, "alias", 2);
+__decorateClass([
+  tenantId({ nullable: true })
+], TagAlias.prototype, "tenantId", 2);
+TagAlias = __decorateClass([
+  TenantScoped({ mode: "optional" }),
+  smrt({
+    tableStrategy: "sti",
+    api: { include: ["list", "get", "create", "update", "delete"] },
+    mcp: { include: ["list", "get", "create"] },
+    cli: true
+  })
+], TagAlias);
+class TagAliasCollection extends SmrtCollection {
+  static _itemClass = TagAlias;
+  /**
+   * Add an alias to a tag (get or create)
+   *
+   * @param tagSlug - The tag slug
+   * @param alias - The alias text
+   * @param language - Optional language code
+   * @param context - Optional context
+   * @returns TagAlias instance
+   */
+  async addAlias(tagSlug, alias, language, context) {
+    const where = { tagSlug, alias };
+    if (language) where.language = language;
+    if (context) where.context = context;
+    const existing = await this.list({ where, limit: 1 });
+    if (existing.length > 0) {
+      return existing[0];
+    }
+    return await this.create({
+      tagSlug,
+      alias,
+      language,
+      context
+    });
+  }
+  /**
+   * Search tags by alias
+   *
+   * @param alias - The alias to search for
+   * @param language - Optional language filter
+   * @returns Array of matching tags
+   */
+  async searchByAlias(alias, language) {
+    const where = { alias };
+    if (language) where.language = language;
+    const aliases = await this.list({ where });
+    const tagSlugs = [...new Set(aliases.map((a) => a.tagSlug))];
+    const { TagCollection: TagCollection2 } = await Promise.resolve().then(() => tags);
+    const tagCollection = await TagCollection2.create(this.options);
+    const tags$1 = [];
+    for (const slug of tagSlugs) {
+      const tag = await tagCollection.get({ slug });
+      if (tag) tags$1.push(tag);
+    }
+    return tags$1;
+  }
+  /**
+   * Get all aliases for a tag
+   *
+   * @param tagSlug - The tag slug
+   * @param language - Optional language filter
+   * @returns Array of TagAlias instances
+   */
+  async getAliasesForTag(tagSlug, language) {
+    const where = { tagSlug };
+    if (language) where.language = language;
+    return await this.list({ where });
+  }
+  /**
+   * Remove an alias by ID
+   *
+   * @param aliasId - The alias UUID
+   */
+  async removeAlias(aliasId) {
+    const alias = await this.get({ id: aliasId });
+    if (alias) {
+      await alias.delete();
+    }
+  }
+  /**
+   * Bulk add aliases to a tag
+   *
+   * @param tagSlug - The tag slug
+   * @param aliases - Array of alias configurations
+   * @returns Array of created TagAlias instances
+   */
+  async bulkAddAliases(tagSlug, aliases) {
+    const created = [];
+    for (const aliasData of aliases) {
+      const tagAlias = await this.addAlias(
+        tagSlug,
+        aliasData.alias,
+        aliasData.language,
+        aliasData.context
+      );
+      created.push(tagAlias);
+    }
+    return created;
+  }
+  /**
+   * Get aliases grouped by language
+   *
+   * @param tagSlug - The tag slug
+   * @returns Map of language code to array of aliases
+   */
+  async getAliasesByLanguage(tagSlug) {
+    const aliases = await this.getAliasesForTag(tagSlug);
+    const grouped = /* @__PURE__ */ new Map();
+    for (const alias of aliases) {
+      const lang = String(alias.language || "default");
+      if (!grouped.has(lang)) {
+        grouped.set(lang, []);
+      }
+      grouped.get(lang)?.push(String(alias.alias));
+    }
+    return grouped;
+  }
+  /**
+   * Find matching aliases (case-insensitive partial match)
+   *
+   * Note: This is a simple implementation. For production use,
+   * consider using full-text search or fuzzy matching.
+   *
+   * @param query - The search query
+   * @param language - Optional language filter
+   * @returns Array of matching TagAlias instances
+   */
+  async findMatchingAliases(query, language) {
+    const where = {};
+    if (language) where.language = language;
+    const all = await this.list({ where });
+    const queryLower = query.toLowerCase();
+    return all.filter(
+      (alias) => String(alias.alias).toLowerCase().includes(queryLower)
+    );
+  }
+  // =========================================================================
+  // Tenant Helper Methods
+  // =========================================================================
+  /**
+   * Find all tag aliases belonging to a specific tenant
+   *
+   * @param tenantId - The tenant ID to filter by
+   * @returns Array of tag aliases for the specified tenant
+   */
+  async findByTenant(tenantId2) {
+    return this.list({ where: { tenantId: tenantId2 } });
+  }
+  /**
+   * Find all global (tenant-less) tag aliases
+   *
+   * @returns Array of global tag aliases with null tenantId
+   */
+  async findGlobal() {
+    return this.list({ where: { tenantId: null } });
+  }
+  /**
+   * Find tag aliases for a tenant including global aliases
+   *
+   * @param tenantId - The tenant ID to filter by
+   * @returns Array of tag aliases for the tenant plus all global aliases
+   */
+  async findWithGlobals(tenantId2) {
+    return this.query(
+      `SELECT * FROM ${this.tableName} WHERE tenant_id = ? OR tenant_id IS NULL`,
+      [tenantId2]
+    );
+  }
+}
+const tagAliases = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  TagAliasCollection
+}, Symbol.toStringTag, { value: "Module" }));
+class TagCollection extends SmrtCollection {
+  static _itemClass = Tag;
+  /**
+   * Get or create a tag with context
+   *
+   * @param slug - Tag slug
+   * @param context - Tag context (default: 'global')
+   * @returns Tag instance
+   */
+  async getOrCreate(slug, context = "global") {
+    const existing = await this.list({
+      where: { slug, context },
+      limit: 1
+    });
+    if (existing.length > 0) {
+      return existing[0];
+    }
+    return await this.create({
+      slug,
+      name: slug.replace(/-/g, " ").replace(/\b\w/g, (l) => l.toUpperCase()),
+      context,
+      level: 0
+    });
+  }
+  /**
+   * Resolve a tag by slug, optionally scoped to a context.
+   *
+   * Tags are identified by `(slug, context)`. When `context` is omitted
+   * and the slug exists in more than one context, this throws a clear
+   * ambiguity error rather than silently picking the first matching row.
+   * Callers that know their context should pass it; callers that work in
+   * a single-context world can leave it off.
+   *
+   * @returns The matching Tag, or `null` if nothing matches.
+   * @throws Error if `context` is omitted and the slug is ambiguous.
+   */
+  async resolveBySlug(slug, context) {
+    const where = { slug };
+    if (context !== void 0) where.context = context;
+    const matches = await this.list({ where, limit: 2 });
+    if (matches.length === 0) return null;
+    if (matches.length > 1) {
+      throw new Error(
+        `Tag slug '${slug}' is ambiguous: resolves to ${matches.length}+ rows across contexts. Pass an explicit \`context\` argument.`
+      );
+    }
+    return matches[0];
+  }
+  /**
+   * List tags by context with optional parent filtering by slug.
+   *
+   * @param context - The context to filter by
+   * @param parentSlug - Optional parent slug to filter children. Pass an
+   *   empty string or `null` to find root tags; pass a slug to find that
+   *   tag's immediate children. Typed as `string | null` so TypeScript
+   *   callers can pass `null` without a cast — the `null` and `''` paths
+   *   are both treated as "roots only".
+   * @returns Array of matching tags
+   */
+  async listByContext(context, parentSlug) {
+    const where = { context };
+    if (parentSlug === "" || parentSlug === null) {
+      where.parentId = null;
+    } else if (parentSlug !== void 0) {
+      const parent = await this.get({ slug: parentSlug, context });
+      if (!parent?.id) return [];
+      where.parentId = parent.id;
+    }
+    return await this.list({ where });
+  }
+  /**
+   * Get root tags (no parent) for a context
+   *
+   * @param context - The context to filter by (default: 'global')
+   * @returns Array of root tags
+   */
+  async getRootTags(context = "global") {
+    return await this.list({
+      where: { context, parentId: null }
+    });
+  }
+  /**
+   * Get immediate children of a parent tag, looked up by slug.
+   *
+   * @param parentSlug - The parent tag slug
+   * @param context - Optional context for the parent lookup. When omitted,
+   *   the parent slug must be unambiguous across contexts (throws if not).
+   * @returns Array of child tags, or `[]` if the parent slug doesn't
+   *   resolve. Children are filtered to the resolved parent's context so
+   *   cross-context children don't leak in.
+   */
+  async getChildren(parentSlug, context) {
+    const parent = await this.resolveBySlug(parentSlug, context);
+    if (!parent?.id) return [];
+    return await this.list({
+      where: { parentId: parent.id, context: parent.context }
+    });
+  }
+  /**
+   * Get tag hierarchy (all ancestors and descendants)
+   *
+   * @param slug - The tag slug
+   * @param context - Optional context for the slug lookup. When omitted,
+   *   the slug must be unambiguous across contexts.
+   * @returns Object with ancestors, current tag, and descendants
+   */
+  async getHierarchy(slug, context) {
+    const tag = await this.resolveBySlug(slug, context);
+    if (!tag) throw new Error(`Tag '${slug}' not found`);
+    const [ancestors, descendants] = await Promise.all([
+      tag.getAncestors(),
+      tag.getDescendants()
+    ]);
+    return { ancestors, current: tag, descendants };
+  }
+  /**
+   * Move a tag to a new parent. Slug-based API; UUIDs resolved internally.
+   *
+   * Cycle detection is inlined here (mirroring `SmrtHierarchical.moveTo`'s
+   * self-loop + descendant checks) so that both `parentId` and the
+   * denormalised `level` field can be persisted in a single `save()`.
+   * Delegating to `moveTo` would write `parentId` first and `level` in a
+   * second save — if the second save failed, the tag would be left with
+   * the new parent but a stale level, breaking the depth cache.
+   *
+   * After the moved tag persists, descendant levels are recalculated
+   * recursively via `updateDescendantLevels`.
+   *
+   * @param slug - The tag to move
+   * @param newParentSlug - The new parent slug (null for root)
+   * @param context - Optional context. When provided, both source and new
+   *   parent are resolved within it. When omitted, both slugs must be
+   *   unambiguous across contexts; the resolver throws otherwise.
+   * @throws Error if either slug fails to resolve, if either slug is
+   *   ambiguous across contexts (no context provided), if source and new
+   *   parent live in different contexts, or if the move would create a
+   *   cycle.
+   */
+  async moveTag(slug, newParentSlug, context) {
+    const tag = await this.resolveBySlug(slug, context);
+    if (!tag) throw new Error(`Tag '${slug}' not found`);
+    let newParent = null;
+    if (newParentSlug) {
+      newParent = await this.resolveBySlug(
+        newParentSlug,
+        context ?? tag.context
+      );
+      if (!newParent) {
+        throw new Error(`Tag '${newParentSlug}' not found`);
+      }
+      if (newParent.context !== tag.context) {
+        throw new Error(
+          `Cannot move Tag '${slug}' (context '${tag.context}') under '${newParentSlug}' (context '${newParent.context}') — contexts must match.`
+        );
+      }
+    }
+    const newParentId = newParent?.id ?? null;
+    if (newParentId !== null && newParentId === tag.id) {
+      throw new Error(`Cannot move Tag ${tag.id} to itself.`);
+    }
+    if (newParentId !== null) {
+      const descendants = await tag.getDescendants();
+      if (descendants.some((d) => d.id === newParentId)) {
+        throw new Error(
+          `Cannot move Tag ${tag.id} under one of its own descendants (${newParentId}) — would create a cycle.`
+        );
+      }
+    }
+    tag.parentId = newParentId;
+    tag.level = newParent ? newParent.level + 1 : 0;
+    await tag.save();
+    await this.updateDescendantLevels(tag);
+  }
+  /**
+   * Merge one tag into another (updates all references)
+   *
+   * Reparents `fromTag`'s direct children onto `toTag` and recalculates
+   * their `level` field plus the level of every descendant — without
+   * this, children moved from a different depth would carry stale
+   * levels relative to their new parent. `TagAlias.tagSlug` references
+   * are also rewritten, then `fromTag` is deleted.
+   *
+   * Note: Consuming packages are responsible for updating their own
+   * join tables (e.g. `asset_tags`).
+   *
+   * @param fromSlug - The tag to merge from
+   * @param toSlug - The tag to merge into
+   * @param context - Optional context. When provided, both tags are
+   *   resolved within it. When omitted, both slugs must be unambiguous
+   *   across contexts.
+   * @throws Error if either slug fails to resolve, if either slug is
+   *   ambiguous, or if the two tags live in different contexts.
+   */
+  async mergeTag(fromSlug, toSlug, context) {
+    const fromTag = await this.resolveBySlug(fromSlug, context);
+    const toTag = await this.resolveBySlug(toSlug, context ?? fromTag?.context);
+    if (!fromTag) throw new Error(`Source tag '${fromSlug}' not found`);
+    if (!toTag) throw new Error(`Target tag '${toSlug}' not found`);
+    if (!fromTag.id) throw new Error(`Source tag '${fromSlug}' has no id`);
+    if (!toTag.id) throw new Error(`Target tag '${toSlug}' has no id`);
+    if (fromTag.context !== toTag.context) {
+      throw new Error(
+        `Cannot merge '${fromSlug}' (context '${fromTag.context}') into '${toSlug}' (context '${toTag.context}') — contexts must match.`
+      );
+    }
+    if (fromTag.id === toTag.id) {
+      throw new Error(`Cannot merge tag '${fromSlug}' into itself.`);
+    }
+    const fromDescendants = await fromTag.getDescendants();
+    if (fromDescendants.some((d) => d.id === toTag.id)) {
+      throw new Error(
+        `Cannot merge '${fromSlug}' into '${toSlug}' — target is a descendant of source (would create a cycle).`
+      );
+    }
+    const children = await this.list({
+      where: { parentId: fromTag.id }
+    });
+    const newChildLevel = toTag.level + 1;
+    for (const child of children) {
+      child.parentId = toTag.id;
+      child.level = newChildLevel;
+      await child.save();
+      await this.updateDescendantLevels(child);
+    }
+    const { TagAliasCollection: TagAliasCollection2 } = await Promise.resolve().then(() => tagAliases);
+    const aliasCollection = await TagAliasCollection2.create(
+      this.options
+    );
+    const aliasContexts = [fromTag.context];
+    if (fromTag.context === "global") {
+      aliasContexts.push("");
+    }
+    const aliases = await aliasCollection.list({
+      where: { tagSlug: fromSlug, context: aliasContexts }
+    });
+    for (const alias of aliases) {
+      alias.tagSlug = toSlug;
+      await alias.save();
+    }
+    await fromTag.delete();
+  }
+  /**
+   * Remove tags with no references (cleanup unused tags)
+   *
+   * Note: This requires consuming packages to provide usage information.
+   * By default, only removes tags with no children and no aliases.
+   *
+   * @param context - Optional context to filter cleanup
+   */
+  async cleanupUnused(context) {
+    const where = {};
+    if (context) where.context = context;
+    const tags2 = await this.list({ where });
+    const { TagAliasCollection: TagAliasCollection2 } = await Promise.resolve().then(() => tagAliases);
+    const aliasCollection = await TagAliasCollection2.create(
+      this.options
+    );
+    let deletedCount = 0;
+    for (const tag of tags2) {
+      if (!tag.id) continue;
+      const children = await this.list({
+        where: { parentId: tag.id },
+        limit: 1
+      });
+      if (children.length > 0) continue;
+      const aliases = await aliasCollection.list({
+        where: { tagSlug: tag.slug },
+        limit: 1
+      });
+      if (aliases.length > 0) continue;
+      await tag.delete();
+      deletedCount++;
+    }
+    return deletedCount;
+  }
+  /**
+   * Calculate hierarchy level for a tag, looking the parent up by slug.
+   *
+   * @param parentSlug - The parent tag slug (null/empty for root)
+   * @param context - Optional context for the parent lookup. When
+   *   omitted, the parent slug must be unambiguous across contexts.
+   * @returns The calculated level (root parent → 1, missing parent → 0)
+   */
+  async calculateLevel(parentSlug, context) {
+    if (!parentSlug) return 0;
+    const parent = await this.resolveBySlug(parentSlug, context);
+    if (!parent) return 0;
+    return parent.level + 1;
+  }
+  /**
+   * Update levels for all descendants after moving a tag
+   *
+   * @param tag - The tag that was moved
+   */
+  async updateDescendantLevels(tag) {
+    if (!tag.id) return;
+    const children = await this.list({
+      where: { parentId: tag.id }
+    });
+    for (const child of children) {
+      child.level = tag.level + 1;
+      await child.save();
+      await this.updateDescendantLevels(child);
+    }
+  }
+  // =========================================================================
+  // Tenant Helper Methods
+  // =========================================================================
+  /**
+   * Find all tags belonging to a specific tenant
+   *
+   * @param tenantId - The tenant ID to filter by
+   * @returns Array of tags for the specified tenant
+   */
+  async findByTenant(tenantId2) {
+    return this.list({ where: { tenantId: tenantId2 } });
+  }
+  /**
+   * Find all global (tenant-less) tags
+   *
+   * @returns Array of global tags with null tenantId
+   */
+  async findGlobal() {
+    return this.list({ where: { tenantId: null } });
+  }
+  /**
+   * Find tags for a tenant including global tags
+   *
+   * @param tenantId - The tenant ID to filter by
+   * @returns Array of tags for the tenant plus all global tags
+   */
+  async findWithGlobals(tenantId2) {
+    return this.query(
+      `SELECT * FROM ${this.tableName} WHERE tenant_id = ? OR tenant_id IS NULL`,
+      [tenantId2]
+    );
+  }
+}
+const tags = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  TagCollection
+}, Symbol.toStringTag, { value: "Module" }));
+export {
+  Tag,
+  TagAlias,
+  TagAliasCollection,
+  TagCollection,
+  calculateLevel,
+  generateUniqueSlug,
+  hasCircularReference,
+  sanitizeSlug,
+  validateSlug
+};
+//# sourceMappingURL=index.js.map