drizzle-cube 0.2.25 → 0.2.27

package/dist/client/chunks/hooks-CAKGR-w0.js

@@ -0,0 +1,828 @@
+import { useState as w, useRef as g, useMemo as h, useEffect as _, useCallback as v } from "react";
+import { a as M, M as x, O as k, Q as $ } from "./charts-DQuOI5HA.js";
+const N = {
+  // String operators
+  equals: {
+    label: "equals",
+    description: "Exact match",
+    requiresValues: !0,
+    supportsMultipleValues: !0,
+    valueType: "any",
+    fieldTypes: ["string", "number", "boolean", "time"]
+  },
+  notEquals: {
+    label: "not equals",
+    description: "Does not match",
+    requiresValues: !0,
+    supportsMultipleValues: !0,
+    valueType: "any",
+    fieldTypes: ["string", "number", "boolean", "time"]
+  },
+  contains: {
+    label: "contains",
+    description: "Contains text (case insensitive)",
+    requiresValues: !0,
+    supportsMultipleValues: !1,
+    valueType: "string",
+    fieldTypes: ["string"]
+  },
+  notContains: {
+    label: "not contains",
+    description: "Does not contain text",
+    requiresValues: !0,
+    supportsMultipleValues: !1,
+    valueType: "string",
+    fieldTypes: ["string"]
+  },
+  startsWith: {
+    label: "starts with",
+    description: "Starts with text",
+    requiresValues: !0,
+    supportsMultipleValues: !1,
+    valueType: "string",
+    fieldTypes: ["string"]
+  },
+  notStartsWith: {
+    label: "not starts with",
+    description: "Does not start with text",
+    requiresValues: !0,
+    supportsMultipleValues: !1,
+    valueType: "string",
+    fieldTypes: ["string"]
+  },
+  endsWith: {
+    label: "ends with",
+    description: "Ends with text",
+    requiresValues: !0,
+    supportsMultipleValues: !1,
+    valueType: "string",
+    fieldTypes: ["string"]
+  },
+  notEndsWith: {
+    label: "not ends with",
+    description: "Does not end with text",
+    requiresValues: !0,
+    supportsMultipleValues: !1,
+    valueType: "string",
+    fieldTypes: ["string"]
+  },
+  like: {
+    label: "like",
+    description: "SQL LIKE pattern matching (case sensitive)",
+    requiresValues: !0,
+    supportsMultipleValues: !1,
+    valueType: "string",
+    fieldTypes: ["string"]
+  },
+  notLike: {
+    label: "not like",
+    description: "SQL NOT LIKE pattern matching (case sensitive)",
+    requiresValues: !0,
+    supportsMultipleValues: !1,
+    valueType: "string",
+    fieldTypes: ["string"]
+  },
+  ilike: {
+    label: "ilike",
+    description: "SQL ILIKE pattern matching (case insensitive)",
+    requiresValues: !0,
+    supportsMultipleValues: !1,
+    valueType: "string",
+    fieldTypes: ["string"]
+  },
+  // Numeric operators
+  gt: {
+    label: "greater than",
+    description: "Greater than value",
+    requiresValues: !0,
+    supportsMultipleValues: !1,
+    valueType: "number",
+    fieldTypes: ["number", "count", "sum", "avg", "min", "max"]
+  },
+  gte: {
+    label: "greater than or equal",
+    description: "Greater than or equal to value",
+    requiresValues: !0,
+    supportsMultipleValues: !1,
+    valueType: "number",
+    fieldTypes: ["number", "count", "sum", "avg", "min", "max"]
+  },
+  lt: {
+    label: "less than",
+    description: "Less than value",
+    requiresValues: !0,
+    supportsMultipleValues: !1,
+    valueType: "number",
+    fieldTypes: ["number", "count", "sum", "avg", "min", "max"]
+  },
+  lte: {
+    label: "less than or equal",
+    description: "Less than or equal to value",
+    requiresValues: !0,
+    supportsMultipleValues: !1,
+    valueType: "number",
+    fieldTypes: ["number", "count", "sum", "avg", "min", "max"]
+  },
+  between: {
+    label: "between",
+    description: "Between two values (inclusive)",
+    requiresValues: !0,
+    supportsMultipleValues: !1,
+    valueType: "number",
+    fieldTypes: ["number", "count", "sum", "avg", "min", "max"]
+  },
+  notBetween: {
+    label: "not between",
+    description: "Not between two values",
+    requiresValues: !0,
+    supportsMultipleValues: !1,
+    valueType: "number",
+    fieldTypes: ["number", "count", "sum", "avg", "min", "max"]
+  },
+  // Array operators
+  in: {
+    label: "in",
+    description: "Matches any of the provided values",
+    requiresValues: !0,
+    supportsMultipleValues: !0,
+    valueType: "any",
+    fieldTypes: ["string", "number", "boolean"]
+  },
+  notIn: {
+    label: "not in",
+    description: "Does not match any of the provided values",
+    requiresValues: !0,
+    supportsMultipleValues: !0,
+    valueType: "any",
+    fieldTypes: ["string", "number", "boolean"]
+  },
+  // Null/Empty operators
+  set: {
+    label: "is set",
+    description: "Is not null/empty",
+    requiresValues: !1,
+    supportsMultipleValues: !1,
+    valueType: "any",
+    fieldTypes: ["string", "number", "time", "boolean"]
+  },
+  notSet: {
+    label: "is not set",
+    description: "Is null/empty",
+    requiresValues: !1,
+    supportsMultipleValues: !1,
+    valueType: "any",
+    fieldTypes: ["string", "number", "time", "boolean"]
+  },
+  isEmpty: {
+    label: "is empty",
+    description: "Is empty string or null",
+    requiresValues: !1,
+    supportsMultipleValues: !1,
+    valueType: "string",
+    fieldTypes: ["string"]
+  },
+  isNotEmpty: {
+    label: "is not empty",
+    description: "Is not empty string and not null",
+    requiresValues: !1,
+    supportsMultipleValues: !1,
+    valueType: "string",
+    fieldTypes: ["string"]
+  },
+  // Date operators
+  inDateRange: {
+    label: "in date range",
+    description: "Between two dates",
+    requiresValues: !0,
+    supportsMultipleValues: !1,
+    valueType: "date",
+    fieldTypes: ["time"]
+  },
+  beforeDate: {
+    label: "before date",
+    description: "Before specified date",
+    requiresValues: !0,
+    supportsMultipleValues: !1,
+    valueType: "date",
+    fieldTypes: ["time"]
+  },
+  afterDate: {
+    label: "after date",
+    description: "After specified date",
+    requiresValues: !0,
+    supportsMultipleValues: !1,
+    valueType: "date",
+    fieldTypes: ["time"]
+  },
+  // Regex operators
+  regex: {
+    label: "matches regex",
+    description: "Matches regular expression pattern",
+    requiresValues: !0,
+    supportsMultipleValues: !1,
+    valueType: "string",
+    fieldTypes: ["string"]
+  },
+  notRegex: {
+    label: "not matches regex",
+    description: "Does not match regular expression pattern",
+    requiresValues: !0,
+    supportsMultipleValues: !1,
+    valueType: "string",
+    fieldTypes: ["string"]
+  },
+  // PostgreSQL array operators
+  arrayContains: {
+    label: "array contains all",
+    description: "Array field contains all specified values (PostgreSQL only)",
+    requiresValues: !0,
+    supportsMultipleValues: !0,
+    valueType: "string",
+    fieldTypes: ["string"]
+  },
+  arrayOverlaps: {
+    label: "array contains any",
+    description: "Array field contains any of the specified values (PostgreSQL only)",
+    requiresValues: !0,
+    supportsMultipleValues: !0,
+    valueType: "string",
+    fieldTypes: ["string"]
+  },
+  arrayContained: {
+    label: "array values in",
+    description: "All array field values are within specified values (PostgreSQL only)",
+    requiresValues: !0,
+    supportsMultipleValues: !0,
+    valueType: "string",
+    fieldTypes: ["string"]
+  }
+}, oe = [
+  { value: "custom", label: "Custom" },
+  { value: "today", label: "Today" },
+  { value: "yesterday", label: "Yesterday" },
+  { value: "this_week", label: "This week" },
+  { value: "this_month", label: "This month" },
+  { value: "this_quarter", label: "This quarter" },
+  { value: "this_year", label: "This year" },
+  { value: "last_7_days", label: "Last 7 days" },
+  { value: "last_30_days", label: "Last 30 days" },
+  { value: "last_n_days", label: "Last N days" },
+  { value: "last_week", label: "Last week" },
+  { value: "last_n_weeks", label: "Last N weeks" },
+  { value: "last_month", label: "Last month" },
+  { value: "last_12_months", label: "Last 12 months" },
+  { value: "last_n_months", label: "Last N months" },
+  { value: "last_quarter", label: "Last quarter" },
+  { value: "last_n_quarters", label: "Last N quarters" },
+  { value: "last_year", label: "Last year" },
+  { value: "last_n_years", label: "Last N years" }
+];
+function G(e) {
+  return "member" in e && "operator" in e && "values" in e;
+}
+function U(e) {
+  return "type" in e && "filters" in e;
+}
+function z(e) {
+  const r = (t) => {
+    if (G(t))
+      return t;
+    if (U(t)) {
+      const s = t.filters.map(r);
+      return t.type === "and" ? { and: s } : { or: s };
+    }
+    return t;
+  };
+  return e.map(r);
+}
+function J(e) {
+  const r = {};
+  return e.measures && e.measures.length > 0 && (r.measures = e.measures), e.dimensions && e.dimensions.length > 0 && (r.dimensions = e.dimensions), e.timeDimensions && e.timeDimensions.length > 0 && (r.timeDimensions = e.timeDimensions), e.filters && e.filters.length > 0 && (r.filters = e.filters), e.order && (r.order = e.order), e.limit && (r.limit = e.limit), e.offset && (r.offset = e.offset), e.segments && e.segments.length > 0 && (r.segments = e.segments), r;
+}
+function q(e) {
+  const r = J(e);
+  return r.filters && r.filters.length > 0 && (r.filters = z(r.filters)), r;
+}
+function ce(e) {
+  const r = [];
+  for (const [t, s] of Object.entries(N))
+    s.fieldTypes.includes(e) && r.push({
+      operator: t,
+      label: s.label
+    });
+  return r;
+}
+function pe(e, r) {
+  const t = {
+    today: "today",
+    yesterday: "yesterday",
+    this_week: "this week",
+    this_month: "this month",
+    this_quarter: "this quarter",
+    this_year: "this year",
+    last_7_days: "last 7 days",
+    last_30_days: "last 30 days",
+    last_week: "last week",
+    last_month: "last month",
+    last_quarter: "last quarter",
+    last_year: "last year",
+    last_12_months: "last 12 months"
+  };
+  if (e.startsWith("last_n_") && r !== void 0 && r > 0) {
+    const s = e.replace("last_n_", ""), n = s.slice(0, -1);
+    return r === 1 ? `last ${n}` : `last ${r} ${s}`;
+  }
+  return t[e] || e;
+}
+function fe(e) {
+  return e.startsWith("last_n_");
+}
+function de(e) {
+  return e.toISOString().split("T")[0];
+}
+function E(e) {
+  const r = /* @__PURE__ */ new WeakSet(), t = (s) => {
+    if (s === null || typeof s != "object")
+      return JSON.stringify(s);
+    if (r.has(s))
+      return '"[Circular]"';
+    if (r.add(s), Array.isArray(s))
+      return `[${s.map((f) => t(f)).join(",")}]`;
+    const n = s;
+    return `{${Object.keys(n).sort().map((f) => `${JSON.stringify(f)}:${t(n[f])}`).join(",")}}`;
+  };
+  return t(e);
+}
+function I(e, r) {
+  const { isValid: t, skip: s = !1, debounceMs: n = 300 } = r, [l, u] = w(null), [f, c] = w(!1), d = g(null), a = g(""), i = g(s), o = h(() => e ? E(e) : "", [e]);
+  return _(() => {
+    const y = i.current && !s;
+    if (i.current = s, !(o === a.current && !y))
+      return d.current && clearTimeout(d.current), t && !s ? (c(!0), d.current = setTimeout(() => {
+        a.current = o, u(e), c(!1);
+      }, n)) : (a.current = o, u(null), c(!1)), () => {
+        d.current && clearTimeout(d.current);
+      };
+  }, [o, t, s, n, e]), {
+    debouncedValue: l,
+    isDebouncing: f
+  };
+}
+const H = 300;
+function C(e) {
+  return e ? ["cube", "load", E(e)] : ["cube", "load", null];
+}
+function Y(e) {
+  if (!e) return !1;
+  const r = !!(e.measures && e.measures.length > 0), t = !!(e.dimensions && e.dimensions.length > 0), s = !!(e.timeDimensions && e.timeDimensions.length > 0);
+  return r || t || s;
+}
+function X(e, r = {}) {
+  const {
+    skip: t = !1,
+    debounceMs: s = H,
+    resetResultSetOnChange: n = !0,
+    staleTime: l = 60 * 1e3,
+    keepPreviousData: u = !0
+  } = r, { cubeApi: f } = M(), c = x(), d = Y(e), { debouncedValue: a, isDebouncing: i } = I(e, {
+    isValid: d,
+    skip: t,
+    debounceMs: s
+  }), o = h(() => a ? q(a) : null, [a]), p = k({
+    queryKey: C(o),
+    queryFn: async () => {
+      if (!o) throw new Error("No query provided");
+      return f.load(o);
+    },
+    enabled: !!o && !t,
+    staleTime: l,
+    placeholderData: u ? (S) => S : void 0
+  }), y = h(() => {
+    if (!p.data) return null;
+    try {
+      return p.data.rawData();
+    } catch {
+      return null;
+    }
+  }, [p.data]), Q = () => {
+    o && c.refetchQueries({ queryKey: C(o) });
+  }, L = () => {
+    c.removeQueries({ queryKey: ["cube", "load"] });
+  };
+  return {
+    resultSet: h(() => p.data ?? null, [p.data, i, n]),
+    rawData: y,
+    isLoading: p.isLoading || i,
+    isFetching: p.isFetching,
+    isDebouncing: i,
+    error: p.error,
+    debouncedQuery: a,
+    isValidQuery: d,
+    refetch: Q,
+    clearCache: L
+  };
+}
+function O(e) {
+  return e.length > 0 && typeof e[0] == "object" && e[0] !== null && "__queryIndex" in e[0];
+}
+function ye(e) {
+  if (!O(e)) return [];
+  const r = /* @__PURE__ */ new Set();
+  for (const t of e) {
+    const s = t.__queryLabel;
+    typeof s == "string" && r.add(s);
+  }
+  return Array.from(r);
+}
+function me(e) {
+  if (!O(e)) return [];
+  const r = /* @__PURE__ */ new Set();
+  for (const t of e) {
+    const s = t.__queryIndex;
+    typeof s == "number" && r.add(s);
+  }
+  return Array.from(r).sort((t, s) => t - s);
+}
+function Z(e, r, t) {
+  const s = [];
+  return e.forEach((n, l) => {
+    const u = n.rawData(), f = t?.[l] || `Query ${l + 1}`;
+    u.forEach((c) => {
+      s.push({
+        ...c,
+        __queryIndex: l,
+        __queryLabel: f
+      });
+    });
+  }), s;
+}
+function ee(e, r, t, s) {
+  const n = /* @__PURE__ */ new Map();
+  return e.forEach((l, u) => {
+    const f = l.rawData(), c = r[u].measures || [];
+    f.forEach((d) => {
+      const a = t.map((o) => String(d[o] ?? "")).join("|");
+      if (!n.has(a)) {
+        const o = {};
+        t.forEach((p) => {
+          o[p] = d[p];
+        }), n.set(a, o);
+      }
+      const i = n.get(a);
+      c.forEach((o) => {
+        o in i || (i[o] = d[o]);
+      }), u === 0 && Object.keys(d).forEach((o) => {
+        !t.includes(o) && !c.includes(o) && (o in i || (i[o] = d[o]));
+      });
+    });
+  }), Array.from(n.values()).sort((l, u) => {
+    const f = String(l[t[0]] ?? ""), c = String(u[t[0]] ?? "");
+    return f.localeCompare(c);
+  });
+}
+function te(e, r, t, s, n) {
+  return e.length === 0 ? [] : e.length === 1 ? e[0].rawData() : t === "merge" && s && s.length > 0 ? ee(e, r, s) : Z(e, r, n);
+}
+function be(e, r) {
+  const t = /* @__PURE__ */ new Set(), s = /* @__PURE__ */ new Set(), n = /* @__PURE__ */ new Set();
+  return e.forEach((l) => {
+    l.measures?.forEach((u) => t.add(u)), l.dimensions?.forEach((u) => s.add(u)), l.timeDimensions?.forEach((u) => n.add(u.dimension));
+  }), {
+    measures: Array.from(t),
+    dimensions: Array.from(s),
+    timeDimensions: Array.from(n)
+  };
+}
+function he(e, r) {
+  if (e.measures && e.measures.length > 0) {
+    const t = e.measures[0], s = t.split(".");
+    return s.length > 1 ? s[s.length - 1] : t;
+  }
+  return `Query ${r + 1}`;
+}
+function ge(e, r) {
+  const t = [];
+  return e.forEach((s, n) => {
+    [
+      ...s.dimensions || [],
+      ...s.timeDimensions?.map((u) => u.dimension) || []
+    ].includes(r) || t.push(n);
+  }), {
+    isValid: t.length === 0,
+    missingInQueries: t
+  };
+}
+const se = 300;
+function F(e) {
+  return e ? ["cube", "multiLoad", E(e)] : ["cube", "multiLoad", null];
+}
+function re(e) {
+  return !e || !e.queries || e.queries.length < 2 ? !1 : e.queries.filter(
+    (t) => t.measures && t.measures.length > 0 || t.dimensions && t.dimensions.length > 0 || t.timeDimensions && t.timeDimensions.length > 0
+  ).length >= 2;
+}
+function ve(e, r = {}) {
+  const {
+    skip: t = !1,
+    debounceMs: s = se,
+    staleTime: n = 60 * 1e3,
+    keepPreviousData: l = !0
+  } = r, { cubeApi: u, batchCoordinator: f, enableBatching: c } = M(), d = x(), a = re(e), { debouncedValue: i, isDebouncing: o } = I(e, {
+    isValid: a,
+    skip: t,
+    debounceMs: s
+  }), p = h(() => i ? {
+    ...i,
+    queries: i.queries.map((b) => q(b))
+  } : null, [i]), y = k({
+    queryKey: F(p),
+    queryFn: async () => {
+      if (!p) throw new Error("No config provided");
+      let b;
+      c && f ? b = await Promise.all(
+        p.queries.map((m) => f.register(m))
+      ) : b = await u.batchLoad(p.queries);
+      const T = b.map((m) => m && "error" in m && m.error ? new Error(m.error) : null), P = b.map((m, V) => {
+        if (T[V]) return null;
+        try {
+          return m.rawData();
+        } catch {
+          return null;
+        }
+      }), A = b.filter((m, V) => !T[V]), j = p.queries.filter((m, V) => !T[V]);
+      return {
+        data: A.length > 0 ? te(
+          A,
+          j,
+          p.mergeStrategy,
+          p.mergeKeys,
+          p.queryLabels
+        ) : [],
+        resultSets: b,
+        perQueryData: P,
+        errors: T,
+        firstError: T.find((m) => m !== null) || null
+      };
+    },
+    enabled: !!p && !t,
+    staleTime: n,
+    placeholderData: l ? (b) => b : void 0
+  }), Q = () => {
+    p && d.refetchQueries({
+      queryKey: F(p)
+    });
+  }, L = y.data?.data ?? null, R = y.data?.resultSets ?? null, S = y.data?.perQueryData ?? null, B = y.data?.errors ?? [], K = y.data?.firstError ?? y.error;
+  return {
+    data: L,
+    resultSets: R,
+    perQueryData: S,
+    isLoading: y.isLoading || o,
+    isFetching: y.isFetching,
+    isDebouncing: o,
+    error: K,
+    errors: B,
+    debouncedConfig: i,
+    isValidConfig: a,
+    refetch: Q
+  };
+}
+function W(e) {
+  return e ? ["cube", "dryRun", E(e)] : ["cube", "dryRun", null];
+}
+function Te(e, r = {}) {
+  const { skip: t = !1, staleTime: s = 300 * 1e3 } = r, { cubeApi: n } = M(), l = h(() => e ? q(e) : null, [e]), u = k({
+    queryKey: W(l),
+    queryFn: async () => {
+      if (!l) throw new Error("No query provided");
+      const c = await n.dryRun(l);
+      return {
+        sql: c.sql,
+        analysis: c.analysis
+      };
+    },
+    enabled: !!l && !t,
+    staleTime: s
+  });
+  return {
+    debugData: {
+      sql: u.data?.sql ?? null,
+      analysis: u.data?.analysis ?? null,
+      loading: u.isLoading,
+      error: u.error ?? null
+    },
+    refetch: () => u.refetch()
+  };
+}
+function ne(e, r = {}) {
+  const { skip: t = !1, staleTime: s = 300 * 1e3 } = r, { cubeApi: n } = M(), l = h(() => e.map((a) => q(a)), [e]), u = $({
+    queries: l.map((a) => ({
+      queryKey: W(a),
+      queryFn: async () => {
+        const i = await n.dryRun(a);
+        return {
+          sql: i.sql,
+          analysis: i.analysis
+        };
+      },
+      enabled: !t,
+      staleTime: s
+    }))
+  }), f = u.map((a) => ({
+    sql: a.data?.sql ?? null,
+    analysis: a.data?.analysis ?? null,
+    loading: a.isLoading,
+    error: a.error ?? null
+  })), c = u.some((a) => a.isLoading);
+  return {
+    debugDataPerQuery: f,
+    isLoading: c,
+    refetchAll: () => {
+      u.forEach((a) => a.refetch());
+    }
+  };
+}
+function Ve(e) {
+  const { queries: r, isMultiQueryMode: t, skip: s = !1, staleTime: n } = e, l = t ? r : r.slice(0, 1);
+  return ne(l, { skip: s, staleTime: n });
+}
+function we(e, r = !0) {
+  const [t, s] = w(null), n = g(""), {
+    resultSet: l,
+    isLoading: u,
+    error: f
+  } = X(t, {
+    skip: !t || !r || !e,
+    debounceMs: 150,
+    // Quick debounce for filter searches
+    keepPreviousData: !0
+  }), c = h(() => {
+    if (!l || u || f || !e)
+      return [];
+    try {
+      const i = l.tablePivot(), o = /* @__PURE__ */ new Set();
+      return i.forEach((p) => {
+        const y = p[e];
+        y != null && y !== "" && o.add(y);
+      }), Array.from(o);
+    } catch (i) {
+      return console.error("Error extracting values from result set:", i), [];
+    }
+  }, [l, u, f, e]);
+  _(() => {
+    (!e || !r) && (s(null), n.current = "");
+  }, [e, r]);
+  const d = v(() => {
+    if (e) {
+      n.current = "";
+      try {
+        const i = {
+          dimensions: [e],
+          limit: 25,
+          order: { [e]: "asc" }
+        };
+        s(i);
+      } catch (i) {
+        console.error("Error creating query:", i);
+      }
+    }
+  }, [e]), a = v((i, o = !1) => {
+    if (e && !(!o && i === n.current)) {
+      n.current = i;
+      try {
+        const p = {
+          dimensions: [e],
+          limit: 25,
+          order: { [e]: "asc" }
+        };
+        i && i.trim() && (p.filters = [{
+          member: e,
+          operator: "contains",
+          values: [i.trim()]
+        }]), s(p);
+      } catch (p) {
+        console.error("Error creating search query:", p);
+      }
+    }
+  }, [e]);
+  return {
+    values: c,
+    loading: u,
+    error: f ? f instanceof Error ? f.message : String(f) : null,
+    refetch: d,
+    searchValues: a
+  };
+}
+function _e(e, r) {
+  const [t, s] = w(e);
+  return _(() => {
+    const n = setTimeout(() => {
+      s(e);
+    }, r);
+    return () => {
+      clearTimeout(n);
+    };
+  }, [e, r]), t;
+}
+const D = 1200, ae = 768;
+function De() {
+  const [e, r] = w(
+    () => typeof window < "u" ? window.innerWidth : D
+  ), t = g(null), s = g(null), n = v((c) => {
+    if (t.current && (t.current.disconnect(), t.current = null), s.current = c, c) {
+      const d = c.offsetWidth;
+      d > 0 && r(d), t.current = new ResizeObserver((a) => {
+        const i = a[0]?.contentRect.width;
+        i && i > 0 && r(i);
+      }), t.current.observe(c);
+    }
+  }, []);
+  _(() => () => {
+    t.current && t.current.disconnect();
+  }, []), _(() => {
+    const c = () => {
+      if (s.current) {
+        const a = s.current.offsetWidth;
+        a > 0 && r(a);
+      }
+    };
+    window.addEventListener("resize", c);
+    const d = setTimeout(c, 100);
+    return () => {
+      window.removeEventListener("resize", c), clearTimeout(d);
+    };
+  }, []);
+  const l = h(() => e >= D ? "desktop" : e >= ae ? "scaled" : "mobile", [e]), u = h(() => l !== "scaled" ? 1 : e / D, [e, l]);
+  return {
+    containerRef: n,
+    containerWidth: e,
+    displayMode: l,
+    scaleFactor: u,
+    isEditable: l === "desktop",
+    designWidth: D
+  };
+}
+function Me({
+  initialConfig: e,
+  onConfigChange: r,
+  onSave: t,
+  onDirtyStateChange: s
+}) {
+  const n = g(e), l = g(!1), u = v(
+    async (a) => {
+      if (l.current) {
+        s && s(!0);
+        try {
+          t && await t(a), n.current = a, s && s(!1);
+        } catch (i) {
+          throw console.error("Save failed:", i), i;
+        }
+      }
+    },
+    [t, s]
+  ), f = v(
+    (a) => {
+      r && r(a);
+      const i = JSON.stringify(a), o = JSON.stringify(n.current);
+      i !== o && (l.current = !0, s && s(!0));
+    },
+    [r, s]
+  ), c = v(() => l.current, []), d = v((a) => {
+    n.current = a, l.current = !1;
+  }, []);
+  return {
+    handleConfigChange: f,
+    handleSave: u,
+    hasChanged: c,
+    resetInitialConfig: d
+  };
+}
+export {
+  oe as D,
+  N as F,
+  ve as a,
+  Te as b,
+  ne as c,
+  Ve as d,
+  Z as e,
+  ee as f,
+  be as g,
+  ye as h,
+  O as i,
+  me as j,
+  he as k,
+  q as l,
+  te as m,
+  F as n,
+  C as o,
+  pe as p,
+  _e as q,
+  ce as r,
+  we as s,
+  fe as t,
+  X as u,
+  ge as v,
+  de as w,
+  De as x,
+  Me as y
+};
+//# sourceMappingURL=hooks-CAKGR-w0.js.map