@camstack/addon-pipeline-analytics 0.1.1

package/dist/index-C3iAUQqS.mjs

@@ -0,0 +1,533 @@
+class ee {
+  constructor() {
+    this.keyToValue = /* @__PURE__ */ new Map(), this.valueToKey = /* @__PURE__ */ new Map();
+  }
+  set(t, r) {
+    this.keyToValue.set(t, r), this.valueToKey.set(r, t);
+  }
+  getByKey(t) {
+    return this.keyToValue.get(t);
+  }
+  getByValue(t) {
+    return this.valueToKey.get(t);
+  }
+  clear() {
+    this.keyToValue.clear(), this.valueToKey.clear();
+  }
+}
+class K {
+  constructor(t) {
+    this.generateIdentifier = t, this.kv = new ee();
+  }
+  register(t, r) {
+    this.kv.getByValue(t) || (r || (r = this.generateIdentifier(t)), this.kv.set(r, t));
+  }
+  clear() {
+    this.kv.clear();
+  }
+  getIdentifier(t) {
+    return this.kv.getByValue(t);
+  }
+  getValue(t) {
+    return this.kv.getByKey(t);
+  }
+}
+class te extends K {
+  constructor() {
+    super((t) => t.name), this.classToAllowedProps = /* @__PURE__ */ new Map();
+  }
+  register(t, r) {
+    typeof r == "object" ? (r.allowProps && this.classToAllowedProps.set(t, r.allowProps), super.register(t, r.identifier)) : super.register(t, r);
+  }
+  getAllowedProps(t) {
+    return this.classToAllowedProps.get(t);
+  }
+}
+function re(e) {
+  if ("values" in Object)
+    return Object.values(e);
+  const t = [];
+  for (const r in e)
+    e.hasOwnProperty(r) && t.push(e[r]);
+  return t;
+}
+function ne(e, t) {
+  const r = re(e);
+  if ("find" in r)
+    return r.find(t);
+  const n = r;
+  for (let s = 0; s < n.length; s++) {
+    const i = n[s];
+    if (t(i))
+      return i;
+  }
+}
+function h(e, t) {
+  Object.entries(e).forEach(([r, n]) => t(n, r));
+}
+function A(e, t) {
+  return e.indexOf(t) !== -1;
+}
+function z(e, t) {
+  for (let r = 0; r < e.length; r++) {
+    const n = e[r];
+    if (t(n))
+      return n;
+  }
+}
+class se {
+  constructor() {
+    this.transfomers = {};
+  }
+  register(t) {
+    this.transfomers[t.name] = t;
+  }
+  findApplicable(t) {
+    return ne(this.transfomers, (r) => r.isApplicable(t));
+  }
+  findByName(t) {
+    return this.transfomers[t];
+  }
+}
+const ie = (e) => Object.prototype.toString.call(e).slice(8, -1), U = (e) => typeof e > "u", oe = (e) => e === null, R = (e) => typeof e != "object" || e === null || e === Object.prototype ? !1 : Object.getPrototypeOf(e) === null ? !0 : Object.getPrototypeOf(e) === Object.prototype, T = (e) => R(e) && Object.keys(e).length === 0, m = (e) => Array.isArray(e), ae = (e) => typeof e == "string", le = (e) => typeof e == "number" && !isNaN(e), ce = (e) => typeof e == "boolean", ue = (e) => e instanceof RegExp, I = (e) => e instanceof Map, O = (e) => e instanceof Set, M = (e) => ie(e) === "Symbol", fe = (e) => e instanceof Date && !isNaN(e.valueOf()), q = (e) => e instanceof Error, B = (e) => typeof e == "number" && isNaN(e), ye = (e) => ce(e) || oe(e) || U(e) || le(e) || ae(e) || M(e), me = (e) => typeof e == "bigint", ge = (e) => e === 1 / 0 || e === -1 / 0, de = (e) => ArrayBuffer.isView(e) && !(e instanceof DataView), pe = (e) => e instanceof URL, S = (e) => e.replace(/\\/g, "\\\\").replace(/\./g, "\\."), k = (e) => e.map(String).map(S).join("."), E = (e, t) => {
+  const r = [];
+  let n = "";
+  for (let i = 0; i < e.length; i++) {
+    let o = e.charAt(i);
+    if (!t && o === "\\") {
+      const g = e.charAt(i + 1);
+      if (g === "\\") {
+        n += "\\", i++;
+        continue;
+      } else if (g !== ".")
+        throw Error("invalid path");
+    }
+    if (o === "\\" && e.charAt(i + 1) === ".") {
+      n += ".", i++;
+      continue;
+    }
+    if (o === ".") {
+      r.push(n), n = "";
+      continue;
+    }
+    n += o;
+  }
+  const s = n;
+  return r.push(s), r;
+};
+function f(e, t, r, n) {
+  return {
+    isApplicable: e,
+    annotation: t,
+    transform: r,
+    untransform: n
+  };
+}
+const x = [
+  f(U, "undefined", () => null, () => {
+  }),
+  f(me, "bigint", (e) => e.toString(), (e) => typeof BigInt < "u" ? BigInt(e) : (console.error("Please add a BigInt polyfill."), e)),
+  f(fe, "Date", (e) => e.toISOString(), (e) => new Date(e)),
+  f(q, "Error", (e, t) => {
+    const r = {
+      name: e.name,
+      message: e.message
+    };
+    return "cause" in e && (r.cause = e.cause), t.allowedErrorProps.forEach((n) => {
+      r[n] = e[n];
+    }), r;
+  }, (e, t) => {
+    const r = new Error(e.message, { cause: e.cause });
+    return r.name = e.name, r.stack = e.stack, t.allowedErrorProps.forEach((n) => {
+      r[n] = e[n];
+    }), r;
+  }),
+  f(ue, "regexp", (e) => "" + e, (e) => {
+    const t = e.slice(1, e.lastIndexOf("/")), r = e.slice(e.lastIndexOf("/") + 1);
+    return new RegExp(t, r);
+  }),
+  f(
+    O,
+    "set",
+    // (sets only exist in es6+)
+    // eslint-disable-next-line es5/no-es6-methods
+    (e) => [...e.values()],
+    (e) => new Set(e)
+  ),
+  f(I, "map", (e) => [...e.entries()], (e) => new Map(e)),
+  f((e) => B(e) || ge(e), "number", (e) => B(e) ? "NaN" : e > 0 ? "Infinity" : "-Infinity", Number),
+  f((e) => e === 0 && 1 / e === -1 / 0, "number", () => "-0", Number),
+  f(pe, "URL", (e) => e.toString(), (e) => new URL(e))
+];
+function P(e, t, r, n) {
+  return {
+    isApplicable: e,
+    annotation: t,
+    transform: r,
+    untransform: n
+  };
+}
+const L = P((e, t) => M(e) ? !!t.symbolRegistry.getIdentifier(e) : !1, (e, t) => ["symbol", t.symbolRegistry.getIdentifier(e)], (e) => e.description, (e, t, r) => {
+  const n = r.symbolRegistry.getValue(t[1]);
+  if (!n)
+    throw new Error("Trying to deserialize unknown symbol");
+  return n;
+}), he = [
+  Int8Array,
+  Uint8Array,
+  Int16Array,
+  Uint16Array,
+  Int32Array,
+  Uint32Array,
+  Float32Array,
+  Float64Array,
+  Uint8ClampedArray
+].reduce((e, t) => (e[t.name] = t, e), {}), $ = P(de, (e) => ["typed-array", e.constructor.name], (e) => [...e], (e, t) => {
+  const r = he[t[1]];
+  if (!r)
+    throw new Error("Trying to deserialize unknown typed array");
+  return new r(e);
+});
+function F(e, t) {
+  return e?.constructor ? !!t.classRegistry.getIdentifier(e.constructor) : !1;
+}
+const G = P(F, (e, t) => ["class", t.classRegistry.getIdentifier(e.constructor)], (e, t) => {
+  const r = t.classRegistry.getAllowedProps(e.constructor);
+  if (!r)
+    return { ...e };
+  const n = {};
+  return r.forEach((s) => {
+    n[s] = e[s];
+  }), n;
+}, (e, t, r) => {
+  const n = r.classRegistry.getValue(t[1]);
+  if (!n)
+    throw new Error(`Trying to deserialize unknown class '${t[1]}' - check https://github.com/blitz-js/superjson/issues/116#issuecomment-773996564`);
+  return Object.assign(Object.create(n.prototype), e);
+}), H = P((e, t) => !!t.customTransformerRegistry.findApplicable(e), (e, t) => ["custom", t.customTransformerRegistry.findApplicable(e).name], (e, t) => t.customTransformerRegistry.findApplicable(e).serialize(e), (e, t, r) => {
+  const n = r.customTransformerRegistry.findByName(t[1]);
+  if (!n)
+    throw new Error("Trying to deserialize unknown custom value");
+  return n.deserialize(e);
+}), we = [G, L, H, $], C = (e, t) => {
+  const r = z(we, (s) => s.isApplicable(e, t));
+  if (r)
+    return {
+      value: r.transform(e, t),
+      type: r.annotation(e, t)
+    };
+  const n = z(x, (s) => s.isApplicable(e, t));
+  if (n)
+    return {
+      value: n.transform(e, t),
+      type: n.annotation
+    };
+}, Q = {};
+x.forEach((e) => {
+  Q[e.annotation] = e;
+});
+const be = (e, t, r) => {
+  if (m(t))
+    switch (t[0]) {
+      case "symbol":
+        return L.untransform(e, t, r);
+      case "class":
+        return G.untransform(e, t, r);
+      case "custom":
+        return H.untransform(e, t, r);
+      case "typed-array":
+        return $.untransform(e, t, r);
+      default:
+        throw new Error("Unknown transformation: " + t);
+    }
+  else {
+    const n = Q[t];
+    if (!n)
+      throw new Error("Unknown transformation: " + t);
+    return n.untransform(e, r);
+  }
+}, p = (e, t) => {
+  if (t > e.size)
+    throw new Error("index out of bounds");
+  const r = e.keys();
+  for (; t > 0; )
+    r.next(), t--;
+  return r.next().value;
+};
+function W(e) {
+  if (A(e, "__proto__"))
+    throw new Error("__proto__ is not allowed as a property");
+  if (A(e, "prototype"))
+    throw new Error("prototype is not allowed as a property");
+  if (A(e, "constructor"))
+    throw new Error("constructor is not allowed as a property");
+}
+const Ee = (e, t) => {
+  W(t);
+  for (let r = 0; r < t.length; r++) {
+    const n = t[r];
+    if (O(e))
+      e = p(e, +n);
+    else if (I(e)) {
+      const s = +n, i = +t[++r] == 0 ? "key" : "value", o = p(e, s);
+      switch (i) {
+        case "key":
+          e = o;
+          break;
+        case "value":
+          e = e.get(o);
+          break;
+      }
+    } else
+      e = e[n];
+  }
+  return e;
+}, V = (e, t, r) => {
+  if (W(t), t.length === 0)
+    return r(e);
+  let n = e;
+  for (let i = 0; i < t.length - 1; i++) {
+    const o = t[i];
+    if (m(n)) {
+      const l = +o;
+      n = n[l];
+    } else if (R(n))
+      n = n[o];
+    else if (O(n)) {
+      const l = +o;
+      n = p(n, l);
+    } else if (I(n)) {
+      if (i === t.length - 2)
+        break;
+      const c = +o, g = +t[++i] == 0 ? "key" : "value", d = p(n, c);
+      switch (g) {
+        case "key":
+          n = d;
+          break;
+        case "value":
+          n = n.get(d);
+          break;
+      }
+    }
+  }
+  const s = t[t.length - 1];
+  if (m(n) ? n[+s] = r(n[+s]) : R(n) && (n[s] = r(n[s])), O(n)) {
+    const i = p(n, +s), o = r(i);
+    i !== o && (n.delete(i), n.add(o));
+  }
+  if (I(n)) {
+    const i = +t[t.length - 2], o = p(n, i);
+    switch (+s == 0 ? "key" : "value") {
+      case "key": {
+        const c = r(o);
+        n.set(c, n.get(o)), c !== o && n.delete(o);
+        break;
+      }
+      case "value": {
+        n.set(o, r(n.get(o)));
+        break;
+      }
+    }
+  }
+  return e;
+}, X = (e) => e < 1;
+function v(e, t, r, n = []) {
+  if (!e)
+    return;
+  const s = X(r);
+  if (!m(e)) {
+    h(e, (l, c) => v(l, t, r, [
+      ...n,
+      ...E(c, s)
+    ]));
+    return;
+  }
+  const [i, o] = e;
+  o && h(o, (l, c) => {
+    v(l, t, r, [
+      ...n,
+      ...E(c, s)
+    ]);
+  }), t(i, n);
+}
+function Re(e, t, r, n) {
+  return v(t, (s, i) => {
+    e = V(e, i, (o) => be(o, s, n));
+  }, r), e;
+}
+function Ie(e, t, r) {
+  const n = X(r);
+  function s(i, o) {
+    const l = Ee(e, E(o, n));
+    i.map((c) => E(c, n)).forEach((c) => {
+      e = V(e, c, () => l);
+    });
+  }
+  if (m(t)) {
+    const [i, o] = t;
+    i.forEach((l) => {
+      e = V(e, E(l, n), () => e);
+    }), o && h(o, s);
+  } else
+    h(t, s);
+  return e;
+}
+const Oe = (e, t) => R(e) || m(e) || I(e) || O(e) || q(e) || F(e, t);
+function Ae(e, t, r) {
+  const n = r.get(e);
+  n ? n.push(t) : r.set(e, [t]);
+}
+function Pe(e, t) {
+  const r = {};
+  let n;
+  return e.forEach((s) => {
+    if (s.length <= 1)
+      return;
+    t || (s = s.map((l) => l.map(String)).sort((l, c) => l.length - c.length));
+    const [i, ...o] = s;
+    i.length === 0 ? n = o.map(k) : r[k(i)] = o.map(k);
+  }), n ? T(r) ? [n] : [n, r] : T(r) ? void 0 : r;
+}
+const Y = (e, t, r, n, s = [], i = [], o = /* @__PURE__ */ new Map()) => {
+  const l = ye(e);
+  if (!l) {
+    Ae(e, s, t);
+    const y = o.get(e);
+    if (y)
+      return n ? {
+        transformedValue: null
+      } : y;
+  }
+  if (!Oe(e, r)) {
+    const y = C(e, r), u = y ? {
+      transformedValue: y.value,
+      annotations: [y.type]
+    } : {
+      transformedValue: e
+    };
+    return l || o.set(e, u), u;
+  }
+  if (A(i, e))
+    return {
+      transformedValue: null
+    };
+  const c = C(e, r), g = c?.value ?? e, d = m(g) ? [] : {}, w = {};
+  h(g, (y, u) => {
+    if (u === "__proto__" || u === "constructor" || u === "prototype")
+      throw new Error(`Detected property ${u}. This is a prototype pollution risk, please remove it from your object.`);
+    const b = Y(y, t, r, n, [...s, u], [...i, e], o);
+    d[u] = b.transformedValue, m(b.annotations) ? w[S(u)] = b.annotations : R(b.annotations) && h(b.annotations, (j, J) => {
+      w[S(u) + "." + J] = j;
+    });
+  });
+  const _ = T(w) ? {
+    transformedValue: d,
+    annotations: c ? [c.type] : void 0
+  } : {
+    transformedValue: d,
+    annotations: c ? [c.type, w] : w
+  };
+  return l || o.set(e, _), _;
+};
+function Z(e) {
+  return Object.prototype.toString.call(e).slice(8, -1);
+}
+function D(e) {
+  return Z(e) === "Array";
+}
+function ke(e) {
+  if (Z(e) !== "Object")
+    return !1;
+  const t = Object.getPrototypeOf(e);
+  return !!t && t.constructor === Object && t === Object.prototype;
+}
+function Te(e, t, r, n, s) {
+  const i = {}.propertyIsEnumerable.call(n, t) ? "enumerable" : "nonenumerable";
+  i === "enumerable" && (e[t] = r), s && i === "nonenumerable" && Object.defineProperty(e, t, {
+    value: r,
+    enumerable: !1,
+    writable: !0,
+    configurable: !0
+  });
+}
+function N(e, t = {}) {
+  if (D(e))
+    return e.map((s) => N(s, t));
+  if (!ke(e))
+    return e;
+  const r = Object.getOwnPropertyNames(e), n = Object.getOwnPropertySymbols(e);
+  return [...r, ...n].reduce((s, i) => {
+    if (i === "__proto__" || D(t.props) && !t.props.includes(i))
+      return s;
+    const o = e[i], l = N(o, t);
+    return Te(s, i, l, e, t.nonenumerable), s;
+  }, {});
+}
+class a {
+  /**
+   * @param dedupeReferentialEqualities  If true, SuperJSON will make sure only one instance of referentially equal objects are serialized and the rest are replaced with `null`.
+   */
+  constructor({ dedupe: t = !1 } = {}) {
+    this.classRegistry = new te(), this.symbolRegistry = new K((r) => r.description ?? ""), this.customTransformerRegistry = new se(), this.allowedErrorProps = [], this.dedupe = t;
+  }
+  serialize(t) {
+    const r = /* @__PURE__ */ new Map(), n = Y(t, r, this, this.dedupe), s = {
+      json: n.transformedValue
+    };
+    n.annotations && (s.meta = {
+      ...s.meta,
+      values: n.annotations
+    });
+    const i = Pe(r, this.dedupe);
+    return i && (s.meta = {
+      ...s.meta,
+      referentialEqualities: i
+    }), s.meta && (s.meta.v = 1), s;
+  }
+  deserialize(t, r) {
+    const { json: n, meta: s } = t;
+    let i = r?.inPlace ? n : N(n);
+    return s?.values && (i = Re(i, s.values, s.v ?? 0, this)), s?.referentialEqualities && (i = Ie(i, s.referentialEqualities, s.v ?? 0)), i;
+  }
+  stringify(t) {
+    return JSON.stringify(this.serialize(t));
+  }
+  parse(t) {
+    return this.deserialize(JSON.parse(t), { inPlace: !0 });
+  }
+  registerClass(t, r) {
+    this.classRegistry.register(t, r);
+  }
+  registerSymbol(t, r) {
+    this.symbolRegistry.register(t, r);
+  }
+  registerCustom(t, r) {
+    this.customTransformerRegistry.register({
+      name: r,
+      ...t
+    });
+  }
+  allowErrorProps(...t) {
+    this.allowedErrorProps.push(...t);
+  }
+}
+a.defaultInstance = new a();
+a.serialize = a.defaultInstance.serialize.bind(a.defaultInstance);
+a.deserialize = a.defaultInstance.deserialize.bind(a.defaultInstance);
+a.stringify = a.defaultInstance.stringify.bind(a.defaultInstance);
+a.parse = a.defaultInstance.parse.bind(a.defaultInstance);
+a.registerClass = a.defaultInstance.registerClass.bind(a.defaultInstance);
+a.registerSymbol = a.defaultInstance.registerSymbol.bind(a.defaultInstance);
+a.registerCustom = a.defaultInstance.registerCustom.bind(a.defaultInstance);
+a.allowErrorProps = a.defaultInstance.allowErrorProps.bind(a.defaultInstance);
+a.serialize;
+a.deserialize;
+a.stringify;
+a.parse;
+a.registerClass;
+a.registerCustom;
+a.registerSymbol;
+a.allowErrorProps;
+export {
+  a as S
+};