@drawbridge/components 0.0.78 → 0.1.0

package/dist/dashboard/lib/hooks.mjs

@@ -0,0 +1,397 @@
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { usePathname, useRouter, useSearchParams } from "next/navigation";
+import { useQuery, useQueryClient } from "@tanstack/react-query";
+const useCopyToClipboard = ({
+  onClick = () => {
+  },
+  value
+} = {}) => {
+  const [copied, setCopied] = useState(false);
+  const onCopy = useCallback(
+    () => {
+      navigator.clipboard.writeText(value);
+      setCopied(true);
+      onClick();
+    },
+    [onClick, value]
+  );
+  useEffect(
+    () => {
+      if (!copied) return;
+      const timer = setTimeout(
+        () => setCopied(false),
+        2e3
+      );
+      return () => clearTimeout(timer);
+    },
+    [copied]
+  );
+  return {
+    copied,
+    onCopy
+  };
+};
+const useCallbacks = ({
+  query,
+  queryClient
+}) => {
+  const router = useRouter();
+  const saves = useRef({
+    accepted: [],
+    pending: [],
+    queue: Promise.resolve()
+  });
+  const onError = useCallback(
+    (response) => {
+      queryClient.setQueryData(
+        ["notice"],
+        {
+          active: true,
+          response
+        }
+      );
+      queryClient.setQueryData(
+        ["modal"],
+        (data) => ({
+          ...data,
+          active: false
+        })
+      );
+    },
+    [queryClient]
+  );
+  return {
+    onError,
+    onSuccess: useCallback(
+      async (response, options = {}) => {
+        var _a;
+        await queryClient.setQueryData(
+          ["notice"],
+          {
+            active: true,
+            response
+          }
+        );
+        await queryClient.setQueryData(
+          ["modal"],
+          (data) => ({
+            ...data,
+            active: false
+          })
+        );
+        if (Array.isArray(options == null ? void 0 : options.invalidate) && ((_a = options == null ? void 0 : options.invalidate) == null ? void 0 : _a.length) > 0) {
+          await Promise.all(
+            options.invalidate.map((props) => queryClient.invalidateQueries(props))
+          );
+        }
+        ;
+        if (options == null ? void 0 : options.redirect) {
+          router.push(options.redirect);
+        }
+        ;
+        if ((query == null ? void 0 : query.refetch) instanceof Function) {
+          await query.refetch(response);
+        }
+        ;
+      },
+      [query, queryClient, router]
+    ),
+    // A SAVE THAT CHANGES THE SCREEN BEFORE THE API ANSWERS, a drag to
+    // reorder: `update` draws the new order into the cached list at once and
+    // `save` sends it. The reorders sent it with nothing listening, so a
+    // refusal ( a 429 under rate limiting ) was dropped: no message, and the
+    // new order stayed on screen until a reload ( QA night-pages-links-ads,
+    // 2026-09-25 ).
+    //
+    // A refused save is undone from memory, not by refetching: the refetch
+    // would ask the limiter that has just said no. Saves go one at a time in
+    // the order they were made, so what the api holds is always known; a
+    // refusal puts that back and draws every save still waiting over it again,
+    // which leaves a second list under the same entry ( campaign fields' lead
+    // and additional ) as it was.
+    optimistic: useCallback(
+      ({ filters, save, update }) => {
+        const current = saves.current;
+        if (!current.pending.length) {
+          current.accepted = queryClient.getQueriesData(filters).filter(([, data]) => data !== void 0);
+        }
+        ;
+        current.pending.push(update);
+        queryClient.setQueriesData(filters, update);
+        const send = async () => {
+          try {
+            await save();
+          } catch (error) {
+            current.pending.shift();
+            current.accepted.forEach(([queryKey, data]) => queryClient.setQueryData(
+              queryKey,
+              current.pending.reduce((value, next) => next(value), data)
+            ));
+            onError(error);
+            return;
+          }
+          ;
+          current.pending.shift();
+          current.accepted = current.accepted.map(([queryKey, data]) => [queryKey, update(data)]);
+        };
+        current.queue = current.queue.then(send, send);
+        return current.queue;
+      },
+      [onError, queryClient]
+    )
+  };
+};
+const useDrawer = ({
+  queryClient
+}) => {
+  return {
+    close: useCallback(
+      () => {
+        queryClient.setQueryData(
+          ["drawer"],
+          (data) => ({
+            ...data,
+            active: false
+          })
+        );
+      },
+      [queryClient]
+    ),
+    open: useCallback(
+      (props) => {
+        queryClient.setQueryData(
+          ["drawer"],
+          {
+            active: true,
+            ...props
+          }
+        );
+      },
+      [queryClient]
+    )
+  };
+};
+const useSort = ({
+  sort: defaultSort,
+  onChange
+}, { param = "sort" } = {}) => {
+  const pathname = usePathname();
+  const searchParams = useSearchParams();
+  const [sorting, setSorting] = useState(
+    () => {
+      const initial = (() => {
+        const owner = searchParams == null ? void 0 : searchParams.get("pathname");
+        if (owner && owner !== pathname) return defaultSort;
+        const encoded = searchParams == null ? void 0 : searchParams.get(param);
+        if (!encoded) return defaultSort;
+        try {
+          return JSON.parse(encoded);
+        } catch {
+          return defaultSort;
+        }
+        ;
+      })();
+      return Object.entries(initial || {}).map(([id, dir]) => ({
+        desc: dir === -1,
+        id
+      }));
+    }
+  );
+  const sort = useMemo(
+    () => {
+      if (!sorting.length) return defaultSort;
+      return Object.fromEntries(sorting.map(({ id, desc }) => [id, desc ? -1 : 1]));
+    },
+    [sorting, defaultSort]
+  );
+  const [prevSorting, setPrevSorting] = useState(sorting);
+  if (sorting !== prevSorting) {
+    setPrevSorting(sorting);
+    onChange == null ? void 0 : onChange();
+  }
+  ;
+  useEffect(
+    () => {
+      if (typeof window === "undefined") return;
+      const url = new URL(window.location.href);
+      if (JSON.stringify(sort) === JSON.stringify(defaultSort)) {
+        url.searchParams.delete(param);
+      } else {
+        url.searchParams.set(param, JSON.stringify(sort));
+        url.searchParams.set("pathname", pathname);
+      }
+      ;
+      if (url.href === window.location.href) return;
+      window.history.replaceState(window.history.state, "", url);
+    },
+    [sort, defaultSort, param, pathname]
+  );
+  useEffect(
+    () => {
+      return () => {
+        if (typeof window === "undefined") return;
+        const url = new URL(window.location.href);
+        url.searchParams.delete(param);
+        url.searchParams.delete("pathname");
+        if (url.href === window.location.href) return;
+        window.history.replaceState(window.history.state, "", url);
+      };
+    },
+    [param]
+  );
+  return {
+    manualSorting: true,
+    onSortingChange: setSorting,
+    sort,
+    sorting
+  };
+};
+const useUrlFilterState = (defaults, { param = "filters" } = {}) => {
+  const pathname = usePathname();
+  const searchParams = useSearchParams();
+  const [state, setState] = useState(
+    () => {
+      const owner = searchParams == null ? void 0 : searchParams.get("pathname");
+      if (owner && owner !== pathname) return defaults;
+      const encoded = searchParams == null ? void 0 : searchParams.get(param);
+      if (!encoded) return defaults;
+      try {
+        return {
+          ...defaults,
+          ...JSON.parse(encoded)
+        };
+      } catch {
+        return defaults;
+      }
+      ;
+    }
+  );
+  const update = useCallback(
+    (next) => {
+      const value = next instanceof Function ? next(state) : next;
+      setState(value);
+      if (typeof window === "undefined") return;
+      const url = new URL(window.location.href);
+      const serialized = JSON.stringify(value);
+      if (serialized === JSON.stringify(defaults)) {
+        url.searchParams.delete(param);
+      } else {
+        url.searchParams.set(param, serialized);
+        url.searchParams.set("pathname", pathname);
+      }
+      ;
+      if (url.href === window.location.href) return;
+      window.history.replaceState(window.history.state, "", url);
+    },
+    [defaults, param, pathname, state]
+  );
+  const clearSearchParams = useCallback(
+    () => {
+      if (typeof window === "undefined") return;
+      const url = new URL(window.location.href);
+      url.searchParams.delete(param);
+      url.searchParams.delete("pathname");
+      if (url.href === window.location.href) return;
+      window.history.replaceState(window.history.state, "", url);
+    },
+    [param]
+  );
+  useEffect(
+    () => () => clearSearchParams(),
+    [clearSearchParams]
+  );
+  return [state, update, clearSearchParams];
+};
+const useModal = ({
+  queryClient
+}) => {
+  return {
+    close: useCallback(
+      () => {
+        queryClient.setQueryData(
+          ["modal"],
+          (data) => ({
+            ...data,
+            active: false
+          })
+        );
+      },
+      [queryClient]
+    ),
+    open: useCallback(
+      (props) => {
+        queryClient.setQueryData(
+          ["modal"],
+          {
+            active: true,
+            ...props
+          }
+        );
+      },
+      [queryClient]
+    )
+  };
+};
+const useSocketRoom = ({
+  arg,
+  enabled,
+  listeners,
+  resync,
+  room
+}) => {
+  const queryClient = useQueryClient();
+  const { data: socket } = useQuery({
+    queryKey: ["socket"],
+    enabled: false,
+    structuralSharing: false
+  });
+  const listenersRef = useRef(listeners);
+  const resyncRef = useRef(resync);
+  useEffect(
+    () => {
+      listenersRef.current = listeners;
+      resyncRef.current = resync;
+    }
+  );
+  const eventsKey = Object.keys(listeners).join(",");
+  useEffect(
+    () => {
+      if (!enabled || !socket) return;
+      const onConnect = () => {
+        socket.emit.apply(
+          socket,
+          arg === void 0 ? ["join." + room] : ["join." + room, arg]
+        );
+        (resyncRef.current || []).forEach((queryKey) => {
+          queryClient.invalidateQueries({
+            queryKey
+          });
+        });
+      };
+      const handlers = Object.keys(listenersRef.current).map((event) => {
+        const handler = (...payload) => {
+          var _a, _b;
+          return (_b = (_a = listenersRef.current) == null ? void 0 : _a[event]) == null ? void 0 : _b.call(_a, ...payload);
+        };
+        socket.on(event, handler);
+        return [event, handler];
+      });
+      if (socket.connected) onConnect();
+      socket.on("connect", onConnect);
+      return () => {
+        socket.off("connect", onConnect);
+        handlers.forEach(([event, handler]) => socket.off(event, handler));
+      };
+    },
+    [arg, enabled, eventsKey, queryClient, room, socket]
+  );
+};
+export {
+  useCallbacks,
+  useCopyToClipboard,
+  useDrawer,
+  useModal,
+  useSocketRoom,
+  useSort,
+  useUrlFilterState
+};

package/dist/dashboard/lib/navigation.js

@@ -0,0 +1,46 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var navigation_exports = {};
+__export(navigation_exports, {
+  interceptHref: () => interceptHref
+});
+module.exports = __toCommonJS(navigation_exports);
+const interceptHref = ({
+  anchor = {},
+  event = {},
+  location
+}) => {
+  if (!anchor.href || typeof anchor.href !== "string") return null;
+  if (event.button) return null;
+  if (event.altKey || event.ctrlKey || event.metaKey || event.shiftKey) return null;
+  if (anchor.target && anchor.target !== "_self") return null;
+  if (anchor.download) return null;
+  let url;
+  try {
+    url = new URL(anchor.href, location.href);
+  } catch {
+    return null;
+  }
+  if (url.origin !== location.origin) return null;
+  if (url.pathname === location.pathname && url.search === location.search) return null;
+  return url.pathname + url.search + url.hash;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  interceptHref
+});

package/dist/dashboard/lib/navigation.mjs

@@ -0,0 +1,23 @@
+const interceptHref = ({
+  anchor = {},
+  event = {},
+  location
+}) => {
+  if (!anchor.href || typeof anchor.href !== "string") return null;
+  if (event.button) return null;
+  if (event.altKey || event.ctrlKey || event.metaKey || event.shiftKey) return null;
+  if (anchor.target && anchor.target !== "_self") return null;
+  if (anchor.download) return null;
+  let url;
+  try {
+    url = new URL(anchor.href, location.href);
+  } catch {
+    return null;
+  }
+  if (url.origin !== location.origin) return null;
+  if (url.pathname === location.pathname && url.search === location.search) return null;
+  return url.pathname + url.search + url.hash;
+};
+export {
+  interceptHref
+};

package/dist/dashboard/lib/otc.js

@@ -0,0 +1,45 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var otc_exports = {};
+__export(otc_exports, {
+  requestOtc: () => requestOtc
+});
+module.exports = __toCommonJS(otc_exports);
+var import_fetch = require("@drawbridge/drawbridge-utils/fetch");
+const requestOtc = async ({ action, body, endpoint, executeRecaptcha }) => {
+  if (!executeRecaptcha) {
+    throw new Error("Still getting ready \u2014 please try again in a moment.");
+  }
+  const recaptcha = await executeRecaptcha(action);
+  const { result } = await (0, import_fetch.request)({
+    body: {
+      ...body,
+      recaptcha
+    },
+    endpoint,
+    method: "POST"
+  });
+  if (!(result == null ? void 0 : result.otcId)) {
+    throw new Error("We could not send your code. Please refresh the page and try again.");
+  }
+  return result.otcId;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  requestOtc
+});

package/dist/dashboard/lib/otc.mjs

@@ -0,0 +1,22 @@
+import { request } from "@drawbridge/drawbridge-utils/fetch";
+const requestOtc = async ({ action, body, endpoint, executeRecaptcha }) => {
+  if (!executeRecaptcha) {
+    throw new Error("Still getting ready \u2014 please try again in a moment.");
+  }
+  const recaptcha = await executeRecaptcha(action);
+  const { result } = await request({
+    body: {
+      ...body,
+      recaptcha
+    },
+    endpoint,
+    method: "POST"
+  });
+  if (!(result == null ? void 0 : result.otcId)) {
+    throw new Error("We could not send your code. Please refresh the page and try again.");
+  }
+  return result.otcId;
+};
+export {
+  requestOtc
+};

package/dist/dashboard/lib/overage.js

@@ -0,0 +1,30 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var overage_exports = {};
+__export(overage_exports, {
+  overageFromForm: () => overageFromForm,
+  overageToForm: () => overageToForm
+});
+module.exports = __toCommonJS(overage_exports);
+const overageToForm = (cents) => Number.isFinite(cents) ? Math.round(cents * 1e6) / 1e8 : "";
+const overageFromForm = (dollars) => Number.isFinite(dollars) ? Math.round(dollars * 1e6) / 1e4 : void 0;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  overageFromForm,
+  overageToForm
+});

package/dist/dashboard/lib/overage.mjs

@@ -0,0 +1,6 @@
+const overageToForm = (cents) => Number.isFinite(cents) ? Math.round(cents * 1e6) / 1e8 : "";
+const overageFromForm = (dollars) => Number.isFinite(dollars) ? Math.round(dollars * 1e6) / 1e4 : void 0;
+export {
+  overageFromForm,
+  overageToForm
+};

package/dist/dashboard/lib/table-actions.js

@@ -0,0 +1,108 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var table_actions_exports = {};
+__export(table_actions_exports, {
+  organizationAction: () => organizationAction
+});
+module.exports = __toCommonJS(table_actions_exports);
+var import_warning = __toESM(require("../../icons/warning"));
+const organizationAction = ({
+  record,
+  onClickSuspended,
+  onClickTerms,
+  onClickUpgrade,
+  redirectTo
+}) => {
+  const {
+    access,
+    id,
+    status,
+    terms,
+    version = {}
+  } = record;
+  const href = "/api/switch/" + id + (redirectTo ? "?redirectTo=" + encodeURIComponent(redirectTo) : "");
+  const isOwner = ["owner"].includes(access);
+  if (!Boolean(version == null ? void 0 : version.valid)) {
+    return {
+      button: {
+        element: "button",
+        type: "button",
+        variant: "success",
+        disabled: Boolean(access !== "owner") || !onClickUpgrade,
+        onClick: onClickUpgrade,
+        text: isOwner ? "Upgrade" : "Owner must upgrade"
+      }
+    };
+  }
+  ;
+  if (!Boolean(terms == null ? void 0 : terms.valid)) {
+    return {
+      button: {
+        element: "button",
+        type: "button",
+        variant: "error",
+        disabled: Boolean(access !== "owner") || !onClickTerms,
+        onClick: onClickTerms,
+        icon: import_warning.default,
+        text: "Update terms"
+      }
+    };
+  }
+  if (status === "suspended") {
+    return {
+      button: {
+        element: "button",
+        type: "button",
+        variant: "error",
+        // A list that passes no handler (shared) still has to stop the
+        // member entering — it just has nothing to explain it with.
+        disabled: !onClickSuspended || Boolean(access !== "owner"),
+        onClick: onClickSuspended,
+        text: "Suspended"
+      }
+    };
+  }
+  ;
+  return {
+    button: {
+      // Plain anchor, not next/link: the target is a route handler whose GET
+      // has side effects and answers with a redirect. A Link would prefetch it
+      // (switching the current org just by scrolling the list) and would follow
+      // the redirect as a soft navigation, rendering /organizations from the
+      // client router cache — a stale list when the session changed underneath
+      // (see @story organizations/list, the refused-switch scenario).
+      element: "a",
+      href,
+      text: "Select"
+    }
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  organizationAction
+});