@crosslink/sdk-browser 0.1.0

package/LICENSE

@@ -0,0 +1,163 @@
+                              Apache License
+                        Version 2.0, January 2004
+                     http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by the
+   copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all other
+   entities that control, are controlled by, or are under common control
+   with that entity. For the purposes of this definition, "control" means
+   (i) the power, direct or indirect, to cause the direction or management
+   of such entity, whether by contract or otherwise, or (ii) ownership of
+   fifty percent (50%) or more of the outstanding shares, or (iii) beneficial
+   ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity exercising
+   permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation source,
+   and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical transformation
+   or translation of a Source form, including but not limited to compiled
+   object code, generated documentation, and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or Object
+   form, made available under the License, as indicated by a copyright notice
+   that is included in or attached to the work.
+
+   "Derivative Works" shall mean any work, whether in Source or Object form,
+   that is based on (or derived from) the Work and for which the editorial
+   revisions, annotations, elaborations, or other modifications represent, as
+   a whole, an original work of authorship. For the purposes of this License,
+   Derivative Works shall not include works that remain separable from, or
+   merely link (or bind by name) to the interfaces of, the Work and Derivative
+   Works thereof.
+
+   "Contribution" shall mean any work of authorship, including the original
+   version of the Work and any modifications or additions to that Work or
+   Derivative Works thereof, that is intentionally submitted to the Licensor
+   for inclusion in the Work by the copyright owner or by an individual or
+   Legal Entity authorized to submit on behalf of the copyright owner. For the
+   purposes of this definition, "submitted" means any form of electronic,
+   verbal, or written communication sent to the Licensor or its representatives,
+   including but not limited to communication on electronic mailing lists,
+   source code control systems, and issue tracking systems that are managed by,
+   or on behalf of, the Licensor for the purpose of discussing and improving
+   the Work, but excluding communication that is conspicuously marked or
+   otherwise designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity on
+   behalf of whom a Contribution has been received by the Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of this
+   License, each Contributor hereby grants to You a perpetual, worldwide,
+   non-exclusive, no-charge, royalty-free, irrevocable copyright license to
+   reproduce, prepare Derivative Works of, publicly display, publicly perform,
+   sublicense, and distribute the Work and such Derivative Works in Source or
+   Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of this
+   License, each Contributor hereby grants to You a perpetual, worldwide,
+   non-exclusive, no-charge, royalty-free, irrevocable (except as stated in
+   this section) patent license to make, have made, use, offer to sell, sell,
+   import, and otherwise transfer the Work, where such license applies only to
+   those patent claims licensable by such Contributor that are necessarily
+   infringed by their Contribution(s) alone or by combination of their
+   Contribution(s) with the Work to which such Contribution(s) was submitted.
+   If You institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work or a
+   Contribution incorporated within the Work constitutes direct or contributory
+   patent infringement, then any patent licenses granted to You under this
+   License for that Work shall terminate as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the Work or
+   Derivative Works thereof in any medium, with or without modifications, and
+   in Source or Object form, provided that You meet the following conditions:
+
+   (a) You must give any other recipients of the Work or Derivative Works
+       a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices stating
+       that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works that You
+       distribute, all copyright, patent, trademark, and attribution notices
+       from the Source form of the Work, excluding those notices that do not
+       pertain to any part of the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its distribution,
+       then any Derivative Works that You distribute must include a readable
+       copy of the attribution notices contained within such NOTICE file,
+       excluding any notices that do not pertain to any part of the Derivative
+       Works, in at least one of the following places: within a NOTICE text
+       file distributed as part of the Derivative Works; within the Source
+       form or documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and wherever
+       such third-party notices normally appear. The contents of the NOTICE
+       file are for informational purposes only and do not modify the License.
+       You may add Your own attribution notices within Derivative Works that
+       You distribute, alongside or as an addendum to the NOTICE text from
+       the Work, provided that such additional attribution notices cannot be
+       construed as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and may
+   provide additional or different license terms and conditions for use,
+   reproduction, or distribution of Your modifications, or for any such
+   Derivative Works as a whole, provided Your use, reproduction, and
+   distribution of the Work otherwise complies with the conditions stated
+   in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise, any
+   Contribution intentionally submitted for inclusion in the Work by You to
+   the Licensor shall be under the terms and conditions of this License,
+   without any additional terms or conditions. Notwithstanding the above,
+   nothing herein shall supersede or modify the terms of any separate license
+   agreement you may have executed with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade names,
+   trademarks, service marks, or product names of the Licensor, except as
+   required for reasonable and customary use in describing the origin of the
+   Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or agreed to in
+   writing, Licensor provides the Work (and each Contributor provides its
+   Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+   KIND, either express or implied, including, without limitation, any warranties
+   or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any risks
+   associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory, whether in
+   tort (including negligence), contract, or otherwise, unless required by
+   applicable law (such as deliberate and grossly negligent acts) or agreed to
+   in writing, shall any Contributor be liable to You for damages, including
+   any direct, indirect, special, incidental, or consequential damages of any
+   character arising as a result of this License or out of the use or inability
+   to use the Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all other
+   commercial damages or losses), even if such Contributor has been advised of
+   the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing the Work
+   or Derivative Works thereof, You may choose to offer, and charge a fee for,
+   acceptance of support, warranty, indemnity, or other liability obligations
+   and/or rights consistent with this License. However, in accepting such
+   obligations, You may act only on Your own behalf and on Your sole
+   responsibility, not on behalf of any other Contributor, and only if You
+   agree to indemnify, defend, and hold each Contributor harmless for any
+   liability incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS

package/README.md

@@ -0,0 +1,11 @@
+# @crosslink/sdk-browser
+
+<p align="center"><img src="https://crosslink.mintlify.site/crosslink.svg" alt="Crosslink" width="320" /></p>
+
+The Crosslink SDK for browsers and installable PWAs, including the canonical pairing widget.
+
+```bash
+npm install @crosslink/sdk-browser
+```
+
+See the [Crosslink quickstart](https://crosslink.mintlify.site/quickstart) and [repository](https://github.com/jacobpowaza/crosslink).

package/dist/chunk-FKNR6EFT.js

@@ -0,0 +1,54 @@
+// src/storage.ts
+var MemorySecureStorage = class {
+  map = /* @__PURE__ */ new Map();
+  get(key) {
+    return this.map.get(key) ?? null;
+  }
+  set(key, value) {
+    this.map.set(key, value);
+  }
+  delete(key) {
+    this.map.delete(key);
+  }
+};
+var LocalStorageSecureStorage = class {
+  constructor(ls) {
+    this.ls = ls;
+  }
+  ls;
+  get(key) {
+    return this.ls.getItem(key);
+  }
+  set(key, value) {
+    this.ls.setItem(key, value);
+  }
+  delete(key) {
+    this.ls.removeItem(key);
+  }
+};
+var JsonStore = class {
+  constructor(storage, key) {
+    this.storage = storage;
+    this.key = key;
+  }
+  storage;
+  key;
+  load(defaults) {
+    const raw = this.storage.get(this.key);
+    if (!raw) return defaults;
+    try {
+      return { ...defaults, ...JSON.parse(raw) };
+    } catch {
+      return defaults;
+    }
+  }
+  save(value) {
+    this.storage.set(this.key, JSON.stringify(value));
+  }
+};
+
+export {
+  MemorySecureStorage,
+  LocalStorageSecureStorage,
+  JsonStore
+};

package/dist/chunk-RCHT4DYR.js

@@ -0,0 +1,221 @@
+// src/secure-storage.ts
+var DB_NAME = "crosslink-secure";
+var DB_VERSION = 1;
+var KEY_STORE = "keys";
+var VALUE_STORE = "values";
+var MASTER_KEY_ID = "master";
+var IV_BYTES = 12;
+function openDb() {
+  return new Promise((resolve, reject) => {
+    const request2 = indexedDB.open(DB_NAME, DB_VERSION);
+    request2.onupgradeneeded = () => {
+      const db = request2.result;
+      if (!db.objectStoreNames.contains(KEY_STORE)) db.createObjectStore(KEY_STORE);
+      if (!db.objectStoreNames.contains(VALUE_STORE)) db.createObjectStore(VALUE_STORE);
+    };
+    request2.onsuccess = () => resolve(request2.result);
+    request2.onerror = () => reject(request2.error ?? new Error("indexedDB open failed"));
+    request2.onblocked = () => reject(new Error("indexedDB open blocked by another tab"));
+  });
+}
+function txDone(tx) {
+  return new Promise((resolve, reject) => {
+    tx.oncomplete = () => resolve();
+    tx.onerror = () => reject(tx.error ?? new Error("indexedDB transaction failed"));
+    tx.onabort = () => reject(tx.error ?? new Error("indexedDB transaction aborted"));
+  });
+}
+function request(req) {
+  return new Promise((resolve, reject) => {
+    req.onsuccess = () => resolve(req.result);
+    req.onerror = () => reject(req.error ?? new Error("indexedDB request failed"));
+  });
+}
+var IndexedDbSecureStorage = class _IndexedDbSecureStorage {
+  constructor(db, key) {
+    this.db = db;
+    this.key = key;
+  }
+  db;
+  key;
+  kind = "indexeddb-aes-gcm";
+  encrypted = true;
+  /**
+   * Opens the store, generating the non-extractable master key on first use.
+   * Rejects when IndexedDB or WebCrypto is unavailable (private-mode Safari,
+   * insecure origins) so the caller can choose its own fallback rather than
+   * being silently downgraded to plaintext.
+   */
+  static async open() {
+    if (typeof indexedDB === "undefined") {
+      throw new Error("IndexedDB is not available in this environment");
+    }
+    const subtle = globalThis.crypto?.subtle;
+    if (!subtle) {
+      throw new Error("WebCrypto subtle is not available (requires a secure origin)");
+    }
+    const db = await openDb();
+    let key = await request(
+      db.transaction(KEY_STORE, "readonly").objectStore(KEY_STORE).get(MASTER_KEY_ID)
+    );
+    if (!key) {
+      key = await subtle.generateKey({ name: "AES-GCM", length: 256 }, false, [
+        "encrypt",
+        "decrypt"
+      ]);
+      const tx = db.transaction(KEY_STORE, "readwrite");
+      tx.objectStore(KEY_STORE).put(key, MASTER_KEY_ID);
+      await txDone(tx);
+    }
+    return new _IndexedDbSecureStorage(db, key);
+  }
+  async get(name) {
+    const stored = await request(
+      this.db.transaction(VALUE_STORE, "readonly").objectStore(VALUE_STORE).get(name)
+    );
+    if (!stored) return null;
+    try {
+      const plain = await crypto.subtle.decrypt(
+        { name: "AES-GCM", iv: new Uint8Array(stored.iv) },
+        this.key,
+        stored.data
+      );
+      return new TextDecoder().decode(plain);
+    } catch {
+      return null;
+    }
+  }
+  async set(name, value) {
+    const iv = crypto.getRandomValues(new Uint8Array(IV_BYTES));
+    const data = await crypto.subtle.encrypt(
+      { name: "AES-GCM", iv },
+      this.key,
+      new TextEncoder().encode(value)
+    );
+    const tx = this.db.transaction(VALUE_STORE, "readwrite");
+    tx.objectStore(VALUE_STORE).put({ iv: iv.buffer, data }, name);
+    await txDone(tx);
+  }
+  async delete(name) {
+    const tx = this.db.transaction(VALUE_STORE, "readwrite");
+    tx.objectStore(VALUE_STORE).delete(name);
+    await txDone(tx);
+  }
+  async keys() {
+    const all = await request(
+      this.db.transaction(VALUE_STORE, "readonly").objectStore(VALUE_STORE).getAllKeys()
+    );
+    return all.map(String);
+  }
+  /** Destroys every stored value and the master key. */
+  async wipe() {
+    const tx = this.db.transaction([VALUE_STORE, KEY_STORE], "readwrite");
+    tx.objectStore(VALUE_STORE).clear();
+    tx.objectStore(KEY_STORE).clear();
+    await txDone(tx);
+  }
+};
+var AsyncStorageAdapter = class {
+  constructor(inner, kind = "sync-adapter", knownKeys = /* @__PURE__ */ new Set()) {
+    this.inner = inner;
+    this.knownKeys = knownKeys;
+    this.kind = kind;
+  }
+  inner;
+  knownKeys;
+  kind;
+  encrypted = false;
+  async get(key) {
+    return this.inner.get(key);
+  }
+  async set(key, value) {
+    this.knownKeys.add(key);
+    this.inner.set(key, value);
+  }
+  async delete(key) {
+    this.knownKeys.delete(key);
+    this.inner.delete(key);
+  }
+  async keys() {
+    return [...this.knownKeys];
+  }
+};
+var HydratedSecureStorage = class _HydratedSecureStorage {
+  constructor(backend, onWriteError) {
+    this.backend = backend;
+    this.onWriteError = onWriteError;
+  }
+  backend;
+  onWriteError;
+  cache = /* @__PURE__ */ new Map();
+  /** serializes writes so a rapid set/delete pair cannot land out of order */
+  flushChain = Promise.resolve();
+  pendingWrites = 0;
+  static async hydrate(backend, options = {}) {
+    const storage = new _HydratedSecureStorage(backend, options.onWriteError);
+    for (const key of await backend.keys()) {
+      const value = await backend.get(key);
+      if (value !== null) storage.cache.set(key, value);
+    }
+    return storage;
+  }
+  get kind() {
+    return this.backend.kind;
+  }
+  get encrypted() {
+    return this.backend.encrypted;
+  }
+  get(key) {
+    return this.cache.get(key) ?? null;
+  }
+  set(key, value) {
+    this.cache.set(key, value);
+    this.enqueue(key, () => this.backend.set(key, value));
+  }
+  delete(key) {
+    this.cache.delete(key);
+    this.enqueue(key, () => this.backend.delete(key));
+  }
+  /** Resolves once every queued write has reached the backend. */
+  flushed() {
+    return this.flushChain;
+  }
+  get pending() {
+    return this.pendingWrites;
+  }
+  enqueue(key, op) {
+    this.pendingWrites += 1;
+    this.flushChain = this.flushChain.then(op).catch((err) => {
+      this.onWriteError?.(err, key);
+    }).finally(() => {
+      this.pendingWrites -= 1;
+    });
+  }
+};
+async function createSecureStorage(options = {}) {
+  try {
+    const backend = await IndexedDbSecureStorage.open();
+    const storage = await HydratedSecureStorage.hydrate(backend, {
+      ...options.onWriteError ? { onWriteError: options.onWriteError } : {}
+    });
+    return { storage, kind: backend.kind, encrypted: true };
+  } catch (err) {
+    if (options.allowPlaintextFallback === false) throw err;
+  }
+  const { LocalStorageSecureStorage, MemorySecureStorage } = await import("./storage-FHFZA2HW.js");
+  if (typeof localStorage !== "undefined") {
+    return {
+      storage: new LocalStorageSecureStorage(localStorage),
+      kind: "localstorage",
+      encrypted: false
+    };
+  }
+  return { storage: new MemorySecureStorage(), kind: "memory", encrypted: false };
+}
+
+export {
+  IndexedDbSecureStorage,
+  AsyncStorageAdapter,
+  HydratedSecureStorage,
+  createSecureStorage
+};