@djangocfg/api 2.1.582 → 2.1.583

package/dist/clients.mjs

@@ -66,77 +66,264 @@ var APIError = class extends Error {
   }
 };
 
-// src/_api/generated/helpers/auth.ts
-var ACCESS_KEY = "cfg.access_token";
-var REFRESH_KEY = "cfg.refresh_token";
-var API_KEY_KEY = "cfg.api_key";
-var isBrowser = typeof window !== "undefined";
-var localStorageBackend = {
-  get(key) {
-    if (!isBrowser) return null;
-    try {
-      return window.localStorage.getItem(key);
-    } catch {
-      return null;
+// src/_api/generated/helpers/keys.ts
+var k = /* @__PURE__ */ __name((key, store, personal) => ({ key, store, personal }), "k");
+var f = /* @__PURE__ */ __name((prefix, store, personal) => ({ prefix, store, personal }), "f");
+var CFG_KEYS = {
+  accessToken: k("cfg.auth.access_token", "local", true),
+  refreshToken: k("cfg.auth.refresh_token", "local", true),
+  apiKey: k("cfg.auth.api_key", "local", true),
+  email: k("cfg.auth.email", "local", false),
+  emailTs: k("cfg.auth.email_ts", "local", false),
+  redirectUrl: k("cfg.auth.redirect_url", "session", true),
+  redirectUrlTs: k("cfg.auth.redirect_url_ts", "session", true),
+  oauthState: k("cfg.auth.oauth_state", "session", true),
+  oauthProvider: k("cfg.auth.oauth_provider", "session", true),
+  oauthRememberMe: k("cfg.auth.oauth_remember_me", "session", true),
+  profileCache: k("cfg.profile.cache", "local", true),
+  monitorSessionId: k("cfg.monitor.session_id", "local", false),
+  monitorSessionCookie: k("cfg.monitor.session_id", "cookie", false),
+  monitorDebug: k("cfg.monitor.debug", "local", false),
+  uiTabId: k("cfg.ui.tab_id", "session", false),
+  uiRouterSerial: k("cfg.ui.router_serial", "session", false),
+  uiState: k("cfg.ui.state", "local", false),
+  chatSpeechLanguage: k("cfg.chat.speech_language", "local", false),
+  chatRecentTools: k("cfg.chat.recent_tools", "local", false),
+  formsSpeechDebug: k("cfg.forms.speech_debug", "local", false),
+  formsSpeechPrefs: k("cfg.forms.speech_prefs", "local", false),
+  agentPlaygroundApiKeyId: k("cfg.agent.playground_api_key_id", "session", true),
+  agentPlaygroundBearer: k("cfg.agent.playground_bearer", "session", true),
+  agentEndpointDoc: k("cfg.agent.endpoint_doc", "session", false)
+};
+var CFG_FAMILIES = {
+  chatDraft: f("cfg.chat.draft.", "session", true),
+  dataTree: f("cfg.data.tree.", "local", false),
+  agentEndpointDraft: f("cfg.agent.endpoint_draft.", "local", false)
+};
+var OWNER_RE = /^[a-z][a-z0-9_]*$/;
+function normalizeSegment(raw) {
+  return raw.trim().toLowerCase().replace(/[^a-z0-9_]+/g, "_").replace(/^_+|_+$/g, "");
+}
+__name(normalizeSegment, "normalizeSegment");
+var hasWindow = /* @__PURE__ */ __name(() => typeof window !== "undefined", "hasWindow");
+function nativeStorage(store) {
+  if (!hasWindow()) return null;
+  try {
+    return store === "session" ? window.sessionStorage : window.localStorage;
+  } catch {
+    return null;
+  }
+}
+__name(nativeStorage, "nativeStorage");
+function cookieNames() {
+  if (!hasWindow()) return [];
+  try {
+    return document.cookie.split("; ").map((part) => decodeURIComponent(part.split("=")[0] ?? "")).filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+__name(cookieNames, "cookieNames");
+function createStorage(owner, options = {}) {
+  if (!OWNER_RE.test(owner)) {
+    throw new TypeError(`createStorage: owner "${owner}" must match ${OWNER_RE}`);
+  }
+  const prefix = `${owner}.`;
+  const pattern = owner === "cfg" ? /^cfg(\.[a-z0-9_]+)+$/ : new RegExp(`^(cfg|${owner})(\\.[a-z0-9_]+)+$`);
+  const cookieMaxAge = options.cookieMaxAgeSeconds ?? 60 * 60 * 24 * 30;
+  const specs = Object.values(options.keys ?? {});
+  const families = Object.values(options.families ?? {});
+  const specByKey = /* @__PURE__ */ new Map();
+  for (const spec of specs) specByKey.set(spec.key, [...specByKey.get(spec.key) ?? [], spec]);
+  const memory = {
+    local: /* @__PURE__ */ new Map(),
+    session: /* @__PURE__ */ new Map(),
+    cookie: /* @__PURE__ */ new Map()
+  };
+  const isValid = /* @__PURE__ */ __name((key) => pattern.test(key), "isValid");
+  const assertValid = /* @__PURE__ */ __name((key) => {
+    if (!isValid(key)) throw new TypeError(`storage key "${key}" must match ${pattern}`);
+  }, "assertValid");
+  const assertOwned = /* @__PURE__ */ __name((key) => {
+    assertValid(key);
+    if (!key.startsWith(prefix)) throw new TypeError(`storage key "${key}" is not owned by "${owner}"`);
+  }, "assertOwned");
+  function rawGet(store, key) {
+    if (!hasWindow()) return null;
+    if (store === "cookie") {
+      try {
+        const escaped = encodeURIComponent(key).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+        const match = document.cookie.match(new RegExp(`(?:^|;\\s*)${escaped}=([^;]*)`));
+        if (match?.[1] !== void 0) return decodeURIComponent(match[1]);
+      } catch {
+      }
+      return memory.cookie.get(key) ?? null;
     }
-  },
-  set(key, value) {
-    if (!isBrowser) return;
     try {
-      if (value === null) window.localStorage.removeItem(key);
-      else window.localStorage.setItem(key, value);
+      const value = nativeStorage(store)?.getItem(key) ?? null;
+      if (value !== null) return value;
     } catch {
     }
+    return memory[store].get(key) ?? null;
   }
-};
-var sessionStorageBackend = {
-  get(key) {
-    if (!isBrowser) return null;
+  __name(rawGet, "rawGet");
+  function rawSet(store, key, value) {
+    if (!hasWindow()) return false;
     try {
-      return window.sessionStorage.getItem(key);
+      if (store === "cookie") {
+        const secure = window.location.protocol === "https:" ? "; Secure" : "";
+        document.cookie = `${encodeURIComponent(key)}=${encodeURIComponent(value)}; Path=/; Max-Age=${cookieMaxAge}; SameSite=Lax${secure}`;
+        if (rawGet("cookie", key) === value && !memory.cookie.has(key)) return true;
+        memory.cookie.set(key, value);
+        return false;
+      }
+      const native = nativeStorage(store);
+      if (!native) throw new Error("storage unavailable");
+      native.setItem(key, value);
+      memory[store].delete(key);
+      return true;
     } catch {
-      return null;
+      memory[store].set(key, value);
+      return false;
     }
-  },
-  set(key, value) {
-    if (!isBrowser) return;
+  }
+  __name(rawSet, "rawSet");
+  function rawRemove(store, key) {
+    memory[store].delete(key);
+    if (!hasWindow()) return;
     try {
-      if (value === null) window.sessionStorage.removeItem(key);
-      else window.sessionStorage.setItem(key, value);
+      if (store === "cookie") {
+        const secure = window.location.protocol === "https:" ? "; Secure" : "";
+        document.cookie = `${encodeURIComponent(key)}=; Path=/; Max-Age=0; SameSite=Lax${secure}`;
+      } else {
+        nativeStorage(store)?.removeItem(key);
+      }
     } catch {
     }
   }
-};
-var COOKIE_MAX_AGE = 60 * 60 * 24 * 30;
-var cookieBackend = {
-  get(key) {
-    if (!isBrowser) return null;
+  __name(rawRemove, "rawRemove");
+  function resolveStore(key, store) {
+    return store ?? specByKey.get(key)?.[0]?.store ?? "local";
+  }
+  __name(resolveStore, "resolveStore");
+  function listKeys(store, startsWith) {
+    const out = [];
     try {
-      const re = new RegExp(`(?:^|;\\s*)${encodeURIComponent(key)}=([^;]*)`);
-      const m = document.cookie.match(re);
-      const value = m?.[1];
-      return value === void 0 ? null : decodeURIComponent(value);
+      const native = nativeStorage(store);
+      if (native) {
+        for (let i = 0; i < native.length; i += 1) {
+          const name = native.key(i);
+          if (name?.startsWith(startsWith)) out.push(name);
+        }
+      }
     } catch {
-      return null;
     }
-  },
-  set(key, value) {
-    if (!isBrowser) return;
-    try {
-      const k = encodeURIComponent(key);
-      const secure = window.location.protocol === "https:" ? "; Secure" : "";
-      if (value === null) {
-        document.cookie = `${k}=; Path=/; Max-Age=0; SameSite=Lax${secure}`;
-      } else {
-        const v = encodeURIComponent(value);
-        document.cookie = `${k}=${v}; Path=/; Max-Age=${COOKIE_MAX_AGE}; SameSite=Lax${secure}`;
+    for (const name of memory[store].keys()) if (name.startsWith(startsWith) && !out.includes(name)) out.push(name);
+    return out;
+  }
+  __name(listKeys, "listKeys");
+  const familyKey = /* @__PURE__ */ __name((family, id) => {
+    const part = normalizeSegment(id);
+    if (!part) throw new TypeError("storage family id is empty after normalisation");
+    return family.prefix + part;
+  }, "familyKey");
+  const api = {
+    owner,
+    key(...parts) {
+      const segments = parts.map(normalizeSegment);
+      if (segments.length === 0 || segments.some((segment) => !segment)) {
+        throw new TypeError(`storage key parts must be non-empty: ${JSON.stringify(parts)}`);
       }
-    } catch {
+      return `${prefix}${segments.join(".")}`;
+    },
+    familyKey,
+    isValid,
+    read(key, store) {
+      assertValid(key);
+      const target = resolveStore(key, store);
+      return rawGet(target, key);
+    },
+    write(key, value, store) {
+      assertOwned(key);
+      const target = resolveStore(key, store);
+      return rawSet(target, key, value);
+    },
+    remove(key, store) {
+      assertOwned(key);
+      const target = resolveStore(key, store);
+      rawRemove(target, key);
+    },
+    readJSON(key, store) {
+      const raw = api.read(key, store);
+      if (raw === null) return null;
+      try {
+        return JSON.parse(raw);
+      } catch {
+        return null;
+      }
+    },
+    writeJSON(key, value, store) {
+      return api.write(key, JSON.stringify(value), store);
+    },
+    keys(store = "local") {
+      return listKeys(store, prefix);
+    },
+    clearAll({ all = false } = {}) {
+      for (const spec of specs) {
+        if (!all && !spec.personal) continue;
+        rawRemove(spec.store, spec.key);
+      }
+      for (const family of families) {
+        if (!all && !family.personal) continue;
+        for (const name of listKeys(family.store, family.prefix)) rawRemove(family.store, name);
+      }
+      if (all) {
+        for (const store of ["local", "session"]) {
+          for (const name of listKeys(store, prefix)) rawRemove(store, name);
+        }
+        for (const name of cookieNames()) if (name.startsWith(prefix)) rawRemove("cookie", name);
+      }
+    },
+    onChange(key, listener, store = "local") {
+      assertValid(key);
+      if (!hasWindow()) return () => {
+      };
+      const handler = /* @__PURE__ */ __name((event) => {
+        if (event.storageArea !== nativeStorage(store)) return;
+        if (event.key === null || event.key === key) listener(event.key === null ? null : event.newValue);
+      }, "handler");
+      window.addEventListener("storage", handler);
+      return () => window.removeEventListener("storage", handler);
     }
-  }
+  };
+  return api;
+}
+__name(createStorage, "createStorage");
+var cfgStorage = createStorage("cfg", {
+  keys: CFG_KEYS,
+  families: CFG_FAMILIES
+});
+
+// src/_api/generated/helpers/auth.ts
+var ACCESS_KEY = "cfg.auth.access_token";
+var REFRESH_KEY = "cfg.auth.refresh_token";
+var API_KEY_KEY = "cfg.auth.api_key";
+var storage = true ? cfgStorage : createStorage2("cfg");
+var isBrowser = typeof window !== "undefined";
+var STORE_OF = {
+  localStorage: "local",
+  sessionStorage: "session",
+  cookie: "cookie"
 };
 function backendFor(mode) {
-  return mode === "cookie" ? cookieBackend : mode === "sessionStorage" ? sessionStorageBackend : localStorageBackend;
+  const store = STORE_OF[mode];
+  return {
+    get: /* @__PURE__ */ __name((key) => storage.read(key, store), "get"),
+    set(key, value) {
+      if (value === null) storage.remove(key, store);
+      else storage.write(key, value, store);
+    }
+  };
 }
 __name(backendFor, "backendFor");
 var _storageMode = "localStorage";
@@ -325,10 +512,12 @@ var auth = {
     notifySessionChanged();
   },
   clearTokens() {
-    for (const backend of [localStorageBackend, sessionStorageBackend, cookieBackend]) {
+    for (const mode of ["localStorage", "sessionStorage", "cookie"]) {
+      const backend = backendFor(mode);
       backend.set(ACCESS_KEY, null);
       backend.set(REFRESH_KEY, null);
     }
+    storage.clearAll();
     notifySessionChanged();
   },
   /** Session-aware: token PRESENT and not past its `exp` (or a live refresh
@@ -520,7 +709,7 @@ function dpopEnabled() {
   }
 }
 __name(dpopEnabled, "dpopEnabled");
-var _DPOP_DB = "cfg-auth";
+var _DPOP_DB = "cfg.auth.dpop";
 var _DPOP_STORE = "keys";
 var _DPOP_KEY_ID = "dpop-ec-p256";
 function _idbOpen() {