@blue-labs/repository-generator 2.0.0-rc.9 → 3.1.0

package/dist/generateRepository-C2IfsNUG.mjs

@@ -0,0 +1,688 @@
+import * as _ from "path";
+import A from "path";
+import w from "fs";
+import { Properties as x, yamlBlueParse as j, BlueIdCalculator as C } from "@blue-labs/language";
+import { OBJECT_CONTRACTS as L, RESERVED_ATTRIBUTES_POINTER_SEGMENTS as Y, validateAttributesAddedPointer as W, parsePointer as G, OBJECT_SCHEMA as T, validateNoCycles as q, validateStableDoesNotDependOnDev as z } from "@blue-labs/repository-contract";
+import J from "fast-json-patch";
+import H from "js-yaml";
+const N = /* @__PURE__ */ new Set([...x.CORE_TYPES]), g = x.CORE_TYPE_NAME_TO_BLUE_ID_MAP, R = "Blue Repository", l = {
+  Dev: "dev",
+  Stable: "stable"
+}, K = /* @__PURE__ */ new Set([
+  ".git",
+  ".github",
+  ".husky",
+  "node_modules",
+  ".nx",
+  ".vscode",
+  ".idea"
+]);
+function Q(e) {
+  const s = w.readdirSync(e, { withFileTypes: !0 }), t = /* @__PURE__ */ new Map();
+  for (const n of s) {
+    if (!n.isDirectory() || K.has(n.name))
+      continue;
+    const r = A.join(e, n.name), o = U(r);
+    if (o.length !== 0)
+      for (const i of o) {
+        const c = i.endsWith(".dev.blue") ? l.Dev : l.Stable, a = X(i), u = Z(a, i), f = `${n.name}/${u}`, p = t.get(f);
+        if (p)
+          throw p.status !== c ? new Error(
+            `Type ${f} has both stable and dev definitions (${p.filePath} and ${i}).`
+          ) : new Error(
+            `Type ${f} is defined multiple times (${p.filePath} and ${i}).`
+          );
+        const y = ee(a, i);
+        t.set(f, {
+          packageName: n.name,
+          typeName: u,
+          status: c,
+          content: a,
+          filePath: i,
+          references: y
+        });
+      }
+  }
+  return t;
+}
+function X(e) {
+  const s = w.readFileSync(e, "utf8"), t = j(s);
+  if (!O(t))
+    throw new Error(`Type file ${e} must contain a YAML object.`);
+  return t;
+}
+function Z(e, s) {
+  if (!O(e) || typeof e.name != "string")
+    throw new Error(`Type file ${s} is missing required "name" field.`);
+  return e.name;
+}
+function U(e) {
+  const s = w.readdirSync(e, { withFileTypes: !0 }), t = [];
+  for (const n of s) {
+    if (n.isDirectory()) {
+      t.push(...U(A.join(e, n.name)));
+      continue;
+    }
+    (n.name.endsWith(".blue") || n.name.endsWith(".dev.blue")) && t.push(A.join(e, n.name));
+  }
+  return t;
+}
+function ee(e, s) {
+  const t = /* @__PURE__ */ new Set(), n = (r) => {
+    if (Array.isArray(r)) {
+      r.forEach((i) => n(i));
+      return;
+    }
+    if (!O(r))
+      return;
+    const o = (i) => {
+      if (typeof i == "string" && !N.has(i)) {
+        if (!i.includes("/"))
+          throw new Error(
+            `Invalid type reference "${i}" in ${s}. Use <Package>/<Type> for non-primitive references.`
+          );
+        t.add(i);
+      }
+    };
+    o(r.type), o(r.itemType), o(r.keyType), o(r.valueType), Object.values(r).forEach((i) => n(i));
+  };
+  return n(e), t;
+}
+function O(e) {
+  return typeof e == "object" && e !== null && !Array.isArray(e);
+}
+function te(e) {
+  const s = /* @__PURE__ */ new Map();
+  for (const [t, n] of e) {
+    const r = /* @__PURE__ */ new Set();
+    for (const o of n.references) {
+      if (!e.has(o))
+        throw new Error(
+          `Type ${t} references unknown alias ${o}. Ensure the target type exists.`
+        );
+      r.add(o);
+    }
+    s.set(t, r);
+  }
+  return s;
+}
+function ne(e) {
+  const s = [], t = /* @__PURE__ */ new Map(), n = (r, o) => {
+    const i = t.get(r);
+    if (i === "visited")
+      return;
+    if (i === "visiting") {
+      const a = [...o, r].join(" -> ");
+      throw new Error(`Circular type dependency detected: ${a}`);
+    }
+    t.set(r, "visiting"), o.push(r);
+    const c = e.get(r) || /* @__PURE__ */ new Set();
+    for (const a of c)
+      n(a, o);
+    o.pop(), t.set(r, "visited"), s.push(r);
+  };
+  for (const r of e.keys())
+    t.has(r) || n(r, []);
+  return s;
+}
+function re(e, s) {
+  const t = /* @__PURE__ */ new Map(), n = (r) => {
+    if (t.has(r))
+      return t.get(r) ?? !1;
+    const o = e.get(r) || /* @__PURE__ */ new Set();
+    for (const i of o) {
+      const c = s.get(i);
+      if (c && (c.status === l.Dev || n(i)))
+        return t.set(r, !0), !0;
+    }
+    return t.set(r, !1), !1;
+  };
+  for (const [r, o] of s)
+    if (o.status === l.Stable && n(r))
+      throw new Error(
+        `Stable type ${r} depends on a dev type. Stable types may only depend on other stable types.`
+      );
+}
+function d(e) {
+  return typeof e == "object" && e !== null && !Array.isArray(e);
+}
+function h(e) {
+  return d(e) ? Object.getPrototypeOf(e) === Object.prototype : !1;
+}
+function S(e) {
+  if (Array.isArray(e))
+    return e.map((s) => S(s));
+  if (h(e)) {
+    const s = {};
+    for (const [t, n] of Object.entries(e))
+      s[t] = S(n);
+    return s;
+  }
+  return e;
+}
+function B(e) {
+  return e.map((s) => ({
+    repositoryVersionIndex: s.repositoryVersionIndex,
+    typeBlueId: s.typeBlueId,
+    attributesAdded: [...s.attributesAdded]
+  }));
+}
+function se(e, s) {
+  const t = /* @__PURE__ */ new Map(), n = /* @__PURE__ */ new Map();
+  for (const r of e) {
+    const o = s.get(r);
+    if (!o)
+      continue;
+    const i = P(
+      S(o.content),
+      t
+    ), c = k(i), a = N.has(o.typeName) ? oe(o.typeName) : C.INSTANCE.calculateSync(c);
+    t.set(r, a), n.set(r, c);
+  }
+  return { aliasToBlueId: t, aliasToPreprocessed: n };
+}
+function P(e, s, t = !1, n = !1) {
+  if (Array.isArray(e))
+    return e.map(
+      (o) => P(
+        o,
+        s,
+        t,
+        n
+      )
+    );
+  if (!d(e))
+    return e;
+  const r = {};
+  for (const [o, i] of Object.entries(e)) {
+    const c = n || o === L;
+    if ((o === "type" || o === "itemType" || o === "keyType" || o === "valueType") && typeof i == "string" && !(t && c)) {
+      if (N.has(i)) {
+        const a = g[i];
+        if (!a)
+          throw new Error(`Missing primitive BlueId for ${i}.`);
+        r[o] = { blueId: a };
+      } else {
+        const a = i, u = s.get(a);
+        if (!u)
+          throw new Error(`Missing BlueId for alias ${a}.`);
+        r[o] = { blueId: u };
+      }
+      continue;
+    }
+    r[o] = P(
+      i,
+      s,
+      t,
+      c
+    );
+  }
+  return r;
+}
+function k(e, s = !1) {
+  if (Array.isArray(e))
+    return { items: e.map((n) => k(n)) };
+  if (h(e)) {
+    if (ae(e))
+      return { blueId: e.blueId };
+    const t = ce(e), n = {};
+    for (const [r, o] of Object.entries(e)) {
+      if (M(o)) {
+        fe(r, t) ? n[r] = o : n[r] = V(
+          o
+        );
+        continue;
+      }
+      n[r] = k(
+        o,
+        t
+      );
+    }
+    return n;
+  }
+  return M(e) ? s ? e : V(e) : e;
+}
+function oe(e) {
+  const s = g[e];
+  if (!s)
+    throw new Error(`Missing primitive BlueId for ${e}.`);
+  return s;
+}
+function V(e) {
+  const s = ie(e), t = { value: e };
+  return s && (t.type = { blueId: s }), t;
+}
+function ie(e) {
+  return typeof e == "string" ? g.Text : typeof e == "boolean" ? g.Boolean : typeof e == "number" ? Number.isInteger(e) ? g.Integer : g.Double : null;
+}
+function M(e) {
+  return e === null || typeof e == "string" || typeof e == "number" || typeof e == "boolean";
+}
+function ae(e) {
+  const s = Object.entries(e);
+  return s.length === 1 && s[0]?.[0] === "blueId" && typeof s[0]?.[1] == "string";
+}
+function ce(e) {
+  return Object.prototype.hasOwnProperty.call(e, "type") || Object.prototype.hasOwnProperty.call(e, "itemType") || Object.prototype.hasOwnProperty.call(e, "keyType") || Object.prototype.hasOwnProperty.call(e, "valueType");
+}
+const ue = /* @__PURE__ */ new Set(["name", "description", "blueId"]);
+function fe(e, s) {
+  return !!(ue.has(e) || s && e === "value");
+}
+const D = new Set(Object.values(g)), pe = /* @__PURE__ */ new Set([
+  "type",
+  "itemType",
+  "valueType",
+  "keyType"
+]), le = /* @__PURE__ */ new Set(["name", "description"]), m = {
+  Unchanged: "unchanged",
+  NonBreaking: "non-breaking",
+  Breaking: "breaking"
+};
+function de(e, s, t, n, r) {
+  const o = J.compare(
+    e,
+    s
+  );
+  if (o.length === 0)
+    return { status: m.Unchanged, attributesAdded: [] };
+  const i = [];
+  let c = !1;
+  for (const a of o) {
+    if (he(a, e, r)) {
+      c = !0;
+      continue;
+    }
+    if (a.op !== "add")
+      return { status: m.Breaking, attributesAdded: [] };
+    if (!me(a))
+      return { status: m.Breaking, attributesAdded: [] };
+    i.push(a.path);
+  }
+  return i.length === 0 && !c ? {
+    status: m.Breaking,
+    attributesAdded: []
+  } : (i.length > 0 && ye(i, t, n), { status: m.NonBreaking, attributesAdded: i });
+}
+function ye(e, s, t) {
+  for (const n of e)
+    try {
+      W(n);
+    } catch (r) {
+      throw new Error(
+        `Invalid attribute pointer "${n}" for ${s}/${t}: ${r.message}`
+      );
+    }
+}
+function me(e) {
+  if (e.op !== "add")
+    return !1;
+  const s = F(e.path);
+  if (s.length === 0)
+    return !1;
+  const t = s.at(-1);
+  return t && /^\d+$/.test(t) || t && pe.has(t) || s.some(
+    (n) => Y.has(n)
+  ) ? !1 : d(e.value) ? !ge(e.value) : t ? le.has(t) : !1;
+}
+function F(e) {
+  try {
+    return G(e);
+  } catch {
+    return [];
+  }
+}
+function ge(e) {
+  const s = [e];
+  for (; s.length; ) {
+    const t = s.pop();
+    if (t) {
+      if (Object.prototype.hasOwnProperty.call(t, "value") || Object.prototype.hasOwnProperty.call(t, "items"))
+        return !0;
+      if (Object.prototype.hasOwnProperty.call(t, T)) {
+        const n = t[T];
+        if (d(n) && n.required === !0)
+          return !0;
+      }
+      for (const [n, r] of Object.entries(t))
+        n !== T && d(r) && s.push(r);
+    }
+  }
+  return !1;
+}
+function he(e, s, t) {
+  if (e.op !== "replace" || typeof e.path != "string")
+    return !1;
+  const n = F(e.path);
+  if (n.length < 2)
+    return !1;
+  const r = n.at(-1), o = n.at(-2);
+  if (!(r === "blueId" && o !== void 0 && (o === "type" || o === "itemType" || o === "keyType" || o === "valueType")))
+    return !1;
+  const i = be(s, n), c = typeof i == "string" ? i : d(i) && typeof i.blueId == "string" ? i.blueId : null, a = typeof e.value == "string" ? e.value : d(e.value) && typeof e.value.blueId == "string" ? e.value.blueId : null;
+  if (c && D.has(c) || a && D.has(a) || !c || !a)
+    return !1;
+  const u = t.get(c), f = t.get(a);
+  if (!u || !f)
+    return !1;
+  for (const p of u)
+    if (f.has(p))
+      return !0;
+  return !1;
+}
+function be(e, s) {
+  let t = e;
+  for (const n of s)
+    if (Array.isArray(t)) {
+      const r = Number(n);
+      if (Number.isNaN(r) || r < 0 || r >= t.length)
+        return;
+      t = t[r];
+    } else if (d(t))
+      t = t[n];
+    else
+      return;
+  return t;
+}
+function we(e) {
+  const s = /* @__PURE__ */ new Map();
+  if (!e)
+    return s;
+  for (const t of e.packages || []) {
+    if (typeof t.name != "string")
+      continue;
+    const n = /* @__PURE__ */ new Map();
+    for (const r of t.types || []) {
+      const o = r.content, i = h(o) && typeof o.name == "string" ? o.name : void 0;
+      i && n.set(i, r);
+    }
+    s.set(t.name, n);
+  }
+  return s;
+}
+function Ie(e, s) {
+  for (const [t, n] of s)
+    for (const [r, o] of n) {
+      const i = `${t}/${r}`;
+      if (!e.has(i) && o.status === l.Stable)
+        throw new Error(
+          `Stable type ${i} was removed. Breaking changes require a new logical type name.`
+        );
+    }
+}
+function Ee({
+  discovered: e,
+  previousTypes: s,
+  aliasToBlueId: t,
+  aliasToPreprocessed: n,
+  nextRepoVersionIndex: r
+}) {
+  const o = /* @__PURE__ */ new Map(), i = ve(s, t);
+  for (const [c, a] of e) {
+    const u = t.get(c);
+    if (!u)
+      throw new Error(`Failed to compute BlueId for type ${c}.`);
+    const f = s.get(a.packageName)?.get(a.typeName) ?? null;
+    if (f && f.status === l.Stable && a.status === l.Dev)
+      throw new Error(
+        `Type ${c} was stable previously and cannot be downgraded to dev. Use a new logical name instead.`
+      );
+    const p = n.get(c) ?? a.content, y = a.status === l.Dev ? Te({ blueId: u, nextRepoVersionIndex: r, previousType: f }) : !f || f.status === l.Dev ? Ae({ blueId: u, nextRepoVersionIndex: r }) : Se({
+      alias: c,
+      blueId: u,
+      nextRepoVersionIndex: r,
+      previousType: f,
+      currentContent: p,
+      packageName: a.packageName,
+      typeName: a.typeName,
+      blueIdAliases: i
+    });
+    y.content = p, y.status = a.status;
+    const b = o.get(a.packageName) ?? [];
+    b.push(y), o.set(a.packageName, b);
+  }
+  return o;
+}
+function ve(e, s) {
+  const t = /* @__PURE__ */ new Map(), n = (r, o) => {
+    const i = t.get(r);
+    if (i) {
+      i.add(o);
+      return;
+    }
+    t.set(r, /* @__PURE__ */ new Set([o]));
+  };
+  for (const [r, o] of e)
+    for (const [i, c] of o) {
+      const a = `${r}/${i}`;
+      for (const u of c.versions ?? [])
+        typeof u.typeBlueId == "string" && n(u.typeBlueId, a);
+    }
+  for (const [r, o] of s)
+    n(o, r);
+  return t;
+}
+function Te({
+  blueId: e,
+  nextRepoVersionIndex: s,
+  previousType: t
+}) {
+  const n = t && t.status === l.Dev ? t : null, r = n?.versions?.length === 1 ? n.versions[0] : null, o = r && r.typeBlueId === e;
+  return {
+    status: l.Dev,
+    content: {},
+    versions: o && n?.versions ? B(n.versions) : [
+      {
+        repositoryVersionIndex: s,
+        typeBlueId: e,
+        attributesAdded: []
+      }
+    ]
+  };
+}
+function Ae({
+  blueId: e,
+  nextRepoVersionIndex: s
+}) {
+  return {
+    status: l.Stable,
+    content: {},
+    versions: [
+      {
+        repositoryVersionIndex: s,
+        typeBlueId: e,
+        attributesAdded: []
+      }
+    ]
+  };
+}
+function Se({
+  alias: e,
+  blueId: s,
+  nextRepoVersionIndex: t,
+  previousType: n,
+  currentContent: r,
+  packageName: o,
+  typeName: i,
+  blueIdAliases: c
+}) {
+  if (!h(n.content))
+    throw new Error(
+      `Type ${e} has non-object content; cannot compute diff for stable versioning.`
+    );
+  const a = de(
+    n.content,
+    r,
+    o,
+    i,
+    c
+  );
+  if (a.status === m.Unchanged) {
+    const u = B(n.versions || []), f = u.at(-1);
+    if (f && f.typeBlueId !== s)
+      throw new Error(
+        `Type ${e} content is unchanged but BlueId differs from previous metadata.`
+      );
+    return {
+      status: l.Stable,
+      content: {},
+      versions: u
+    };
+  }
+  if (a.status === m.NonBreaking)
+    return {
+      status: l.Stable,
+      content: {},
+      versions: [
+        ...B(n.versions || []),
+        {
+          repositoryVersionIndex: t,
+          typeBlueId: s,
+          attributesAdded: a.attributesAdded
+        }
+      ]
+    };
+  throw new Error(
+    `Breaking change detected in stable type ${e}. Introduce a new type name for breaking changes.`
+  );
+}
+function Be(e) {
+  return Array.from(e.entries()).map(([s, t]) => ({
+    name: s,
+    types: t.map((n) => ({
+      ...n,
+      versions: [...n.versions].sort(
+        (r, o) => r.repositoryVersionIndex - o.repositoryVersionIndex
+      )
+    })).sort((n, r) => {
+      const o = h(n.content) && typeof n.content.name == "string" ? n.content.name : "", i = h(r.content) && typeof r.content.name == "string" ? r.content.name : "";
+      return o.localeCompare(i);
+    })
+  })).sort((s, t) => s.name.localeCompare(t.name));
+}
+function Pe(e) {
+  return C.INSTANCE.calculateSync(
+    e
+  );
+}
+function ke(e, s, t) {
+  const n = s?.repositoryVersions.at(-1), r = !n || n !== t, o = s?.repositoryVersions ? [...s.repositoryVersions] : [];
+  return r && o.push(t), { document: {
+    name: R,
+    packages: e,
+    repositoryVersions: o
+  }, changed: r };
+}
+function Ne(e, s, t) {
+  const n = {
+    name: R,
+    repositoryVersions: s,
+    packages: Re(e, t)
+  };
+  q(n), z(n);
+}
+function Re(e, s) {
+  const t = {};
+  for (const n of e) {
+    const r = Oe(n.name, s), o = {}, i = {};
+    for (const c of n.types) {
+      const a = c.versions?.[c.versions.length - 1]?.typeBlueId;
+      if (!a)
+        throw new Error(
+          `Type ${n.name} is missing a current BlueId in versions.`
+        );
+      const u = $e(c);
+      o[a] = {
+        status: c.status,
+        name: u,
+        versions: c.versions ?? []
+      }, i[a] = c.content;
+    }
+    t[n.name] = {
+      name: n.name,
+      aliases: r,
+      typesMeta: o,
+      contents: i,
+      schemas: {}
+    };
+  }
+  return t;
+}
+function Oe(e, s) {
+  const t = {}, n = `${e}/`;
+  return s.forEach((r, o) => {
+    o.startsWith(n) && (t[o] = r);
+  }), t;
+}
+function $e(e) {
+  const s = h(e.content) && typeof e.content.name == "string" ? e.content.name : null;
+  if (!s)
+    throw new Error('Type content is missing required "name" field.');
+  return s;
+}
+function _e(e) {
+  if (!w.existsSync(e))
+    return { previous: null };
+  const s = w.readFileSync(e, "utf8"), t = j(s);
+  if (!t || !d(t))
+    throw new Error("Existing BlueRepository.blue is not a valid object.");
+  const n = t, r = n.packages, o = n.repositoryVersions, i = Array.isArray(r) && r.every(
+    (p) => d(p) && typeof p.name == "string" && Array.isArray(p.types)
+  ), c = Array.isArray(o) && o.every((p) => typeof p == "string");
+  if (!i || !c)
+    throw new Error(
+      "Invalid BlueRepository.blue structure: expected { packages: BluePackage[], repositoryVersions: string[] }"
+    );
+  const a = r, u = o, f = {
+    name: typeof n.name == "string" ? n.name : R,
+    packages: a,
+    repositoryVersions: u
+  };
+  return { existingYaml: s, previous: f };
+}
+function Ve(e) {
+  return H.dump(e, { lineWidth: -1 });
+}
+function Fe(e) {
+  const s = _.resolve(e.repoRoot), t = _.resolve(e.blueRepositoryPath), { existingYaml: n, previous: r } = _e(t), o = Q(s), i = we(r);
+  Ie(o, i);
+  const c = te(o), a = ne(c);
+  re(c, o);
+  const { aliasToBlueId: u, aliasToPreprocessed: f } = se(
+    a,
+    o
+  ), p = r ? r.repositoryVersions.length : 0, y = Ee({
+    discovered: o,
+    previousTypes: i,
+    aliasToBlueId: u,
+    aliasToPreprocessed: f,
+    nextRepoVersionIndex: p
+  }), b = Be(y), E = Pe(b), { document: I, changed: v } = ke(
+    b,
+    r,
+    E
+  );
+  Ne(
+    I.packages,
+    I.repositoryVersions,
+    u
+  );
+  const $ = Ve(I);
+  if (r && !v && n && n !== $)
+    throw new Error(
+      "BlueRepository.blue content differs from regenerated output while RepoBlueId is unchanged. Please revert manual edits or rerun in write mode."
+    );
+  return e.verbose && console.info(
+    `[repository-generator] RepoBlueId: ${E} (${v ? "changed" : "unchanged"})`
+  ), {
+    document: I,
+    currentRepoBlueId: E,
+    previousRepoBlueId: r?.repositoryVersions.at(-1),
+    changed: v || !n,
+    yaml: $,
+    existingYaml: n
+  };
+}
+export {
+  Fe as g
+};

package/dist/index.js

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const e=require("./generateRepository-Dg6UVHvd.js");exports.generateRepository=e.generateRepository;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const e=require("./generateRepository-BwxSxjH3.js");exports.generateRepository=e.generateRepository;

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { g as r } from "./generateRepository-BAWUEf72.mjs";
+import { g as r } from "./generateRepository-C2IfsNUG.mjs";
 export {
   r as generateRepository
 };

package/dist/lib/core/blueIds.d.ts

@@ -1,9 +1,9 @@
-import { JsonBlueValue } from '@blue-labs/language';
+import { JsonValue } from '@blue-labs/shared-utils';
 import { Alias, DiscoveredType, JsonMap } from './internalTypes';
 export declare function computeBlueIds(topoOrder: Alias[], discovered: Map<Alias, DiscoveredType>): {
     aliasToBlueId: Map<Alias, string>;
     aliasToPreprocessed: Map<Alias, JsonMap>;
 };
-export declare function substituteAliases(content: JsonBlueValue, aliasToBlueId: Map<Alias, string>, skipContracts?: boolean, underContracts?: boolean): JsonBlueValue;
-export declare function normalizeForBlueId(value: JsonBlueValue, parentHasExplicitType?: boolean): JsonBlueValue;
+export declare function substituteAliases(content: JsonValue, aliasToBlueId: Map<Alias, string>, skipContracts?: boolean, underContracts?: boolean): JsonValue;
+export declare function normalizeForBlueId(value: JsonValue, parentHasExplicitType?: boolean): JsonValue;
 //# sourceMappingURL=blueIds.d.ts.map

package/dist/lib/core/blueIds.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"blueIds.d.ts","sourceRoot":"","sources":["../../../src/lib/core/blueIds.ts"],"names":[],"mappings":"AAAA,OAAO,EAAoB,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACtE,OAAO,EAAE,KAAK,EAAE,cAAc,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAIjE,wBAAgB,cAAc,CAC5B,SAAS,EAAE,KAAK,EAAE,EAClB,UAAU,EAAE,GAAG,CAAC,KAAK,EAAE,cAAc,CAAC,GACrC;IACD,aAAa,EAAE,GAAG,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;IAClC,mBAAmB,EAAE,GAAG,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;CAC1C,CAwBA;AAED,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,aAAa,EACtB,aAAa,EAAE,GAAG,CAAC,KAAK,EAAE,MAAM,CAAC,EACjC,aAAa,UAAQ,EACrB,cAAc,UAAQ,GACrB,aAAa,CAuDf;AAED,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,aAAa,EACpB,qBAAqB,UAAQ,GAC5B,aAAa,CA6Cf"}
+{"version":3,"file":"blueIds.d.ts","sourceRoot":"","sources":["../../../src/lib/core/blueIds.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AACzD,OAAO,EAAE,KAAK,EAAE,cAAc,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAIjE,wBAAgB,cAAc,CAC5B,SAAS,EAAE,KAAK,EAAE,EAClB,UAAU,EAAE,GAAG,CAAC,KAAK,EAAE,cAAc,CAAC,GACrC;IACD,aAAa,EAAE,GAAG,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;IAClC,mBAAmB,EAAE,GAAG,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;CAC1C,CAwBA;AAED,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,SAAS,EAClB,aAAa,EAAE,GAAG,CAAC,KAAK,EAAE,MAAM,CAAC,EACjC,aAAa,UAAQ,EACrB,cAAc,UAAQ,GACrB,SAAS,CAuDX;AAED,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,SAAS,EAChB,qBAAqB,UAAQ,GAC5B,SAAS,CA2CX"}