@secrecy/lib 1.7.0 → 1.8.0

package/dist/lib/utils/popup-tools.js

@@ -0,0 +1,180 @@
+/**
+ * TS Rewrite of https://github.com/enhancv/popup-tools
+ */
+const defaultOptions = {
+    width: 700,
+    height: 520,
+    menubar: 'no',
+    resizable: 'yes',
+    location: 'yes',
+    scrollbars: 'no',
+    centered: true,
+};
+let popupCount = 1;
+/**
+ * Return options converted to a string
+ *
+ * @param  {Object} options
+ * @return {String}
+ */
+function optionsToString(options) {
+    return Object.entries(options)
+        .map(([k, v]) => `${k}=${v}`)
+        .join(',');
+}
+/**
+ * Get a unique name on each call
+ * @return {String}
+ */
+function defaultPopupName() {
+    popupCount += 1;
+    return `Popup ${popupCount}`;
+}
+/**
+ * Convert "centered: true" key into concrete left and top arguments
+ * Both can be overwritten
+ *
+ * @param  {Object} options
+ * @return {Object}
+ */
+function optionsResolveCentered(options) {
+    if (options.width === undefined || options.height === undefined) {
+        throw new Error('Should have width and height');
+    }
+    const result = { ...options };
+    const width = window.outerWidth - options.width;
+    const height = window.outerHeight - options.height;
+    if (options.centered === true) {
+        result.left = options.left ?? Math.round(window.screenX + width / 2);
+        result.top = options.top ?? Math.round(window.screenY + height / 2.5);
+        delete result.centered;
+    }
+    return result;
+}
+/**
+ * Create a form element, add hidden inputs for all the post data
+ * and post it into a newly opened popup
+ *
+ * @param  {String} url
+ * @param  {Object} postData
+ * @param  {String} name
+ * @param  {Object} options
+ * @return {Object}
+ */
+function openPopupWithPost(url, postData, name, options) {
+    const form = document.createElement('form');
+    let win = null;
+    form.setAttribute('method', 'post');
+    form.setAttribute('action', url);
+    form.setAttribute('target', name);
+    Object.keys(postData).forEach(function addFormItem(key) {
+        const input = document.createElement('input');
+        input.type = 'hidden';
+        input.name = key;
+        input.value = postData[key];
+        form.appendChild(input);
+    });
+    document.body.appendChild(form);
+    win = window.open('/', name, options);
+    win?.document.write('Loading...');
+    form.submit();
+    document.body.removeChild(form);
+    return win;
+}
+/**
+ * Open a popup using the first argument. Wait for it to close.
+ * Returns the window object
+ *
+ * @param  {Function}
+ * @param  {String}
+ * @param  {String}
+ * @param  {Object}
+ * @param  {Function}
+ * @return {Object}
+ */
+function popupExecute(execute, url, name, options, callback) {
+    const popupName = name ?? defaultPopupName();
+    const popupOptions = optionsResolveCentered(Object.assign({}, defaultOptions, options));
+    const popupCallback = callback ??
+        function noop() {
+            //
+        };
+    const optionsString = optionsToString(popupOptions);
+    const win = execute(url, popupName, optionsString);
+    let isMessageSent = false;
+    let interval;
+    function popupCallbackOnce(err, data) {
+        if (!isMessageSent) {
+            isMessageSent = true;
+            popupCallback(err, data);
+        }
+    }
+    function onMessage(message) {
+        const data = message !== undefined ? message.data : undefined;
+        if (data !== undefined && data.id === popupName) {
+            popupCallbackOnce(undefined, data.data);
+            window.removeEventListener('message', onMessage);
+            clearInterval(interval);
+        }
+    }
+    window.addEventListener('message', onMessage, false);
+    if (win !== null) {
+        interval = window.setInterval(function closePopupCallback() {
+            if (win === null || win.closed) {
+                setTimeout(function delayWindowClosing() {
+                    clearInterval(interval);
+                    popupCallbackOnce(new Error('Popup closed'));
+                }, 500);
+            }
+        }, 100);
+    }
+    else {
+        popupCallbackOnce(new Error('Popup blocked'));
+    }
+    return win;
+}
+/**
+ * Open a popup using the first argument.
+ * Wait for it to close and call the callback.
+ * Set the options string using the options object
+ * Returns the window object
+ *
+ * @param  {String} url
+ * @param  {String} name
+ * @param  {Object} options
+ * @param  {Function} callback
+ * @return {Object}
+ */
+export function popup(url, name, options, callback) {
+    return popupExecute(window.open, url, name, options, callback);
+}
+/**
+ * Open a popup using the first argument.
+ * Post the data into the open popup.
+ * Wait for it to close and call the callback.
+ * Set the options string using the options object
+ * Returns the window object
+ *
+ * @param  {String} url
+ * @param  {Object} postData
+ * @param  {String} name
+ * @param  {Object} options
+ * @param  {Function} callback
+ * @return {Object}
+ */
+export function popupWithPost(url, postData, name, options, callback) {
+    function openWithPostData(popupUrl, popupName, optionsString) {
+        return openPopupWithPost(popupUrl, postData, popupName, optionsString);
+    }
+    return popupExecute(openWithPostData, url, name, options, callback);
+}
+/**
+ * Return html that when executed, will trigger the popup to callback with a response
+ *
+ * @param  {Object}
+ * @return {String}
+ */
+export function popupResponse(id, data) {
+    const jsonData = JSON.stringify({ id, data });
+    return `<script>window.opener.postMessage(${jsonData}, "*");setTimeout(function() { window.close(); }, 50);</script>`;
+}

package/dist/lib/utils/promise.js

@@ -0,0 +1,20 @@
+export const promiseAllLimit = async (n, list) => {
+    const head = list.slice(0, n);
+    const tail = list.slice(n);
+    const result = [];
+    const execute = async (promise, i, runNext) => {
+        result[i] = await promise();
+        await runNext();
+    };
+    const runNext = async () => {
+        const i = list.length - tail.length;
+        const promise = tail.shift();
+        if (promise !== undefined) {
+            await execute(promise, i, runNext);
+        }
+    };
+    await Promise.all(head.map(async (promise, i) => {
+        await execute(promise, i, runNext);
+    }));
+    return result;
+};

package/dist/lib/utils/store-buddy.js

@@ -0,0 +1,60 @@
+/**
+ * Create persistent or temporary client-side storage with a portable,
+ * type-safe wrapper around the [Web Storage API](https://developer.mozilla.org/en-US/docs/Web/API/Web_Storage_API).
+ * @param key The key used to access the stored value.
+ * @param [session] Save data in sessionStorage (`true`) or in localStorage
+ * (`false`). Default is `false`.
+ * @example
+ *
+ * ```ts
+ * import storeBuddy from "store-buddy";
+ *
+ * // "foo" is the key used to access the stored value, which is created in the
+ * // method `init`
+ * const storage1 = storeBuddy("foo").init("bar");
+ *
+ * // Using sessionStorage instead of localStorage is possible by specifying
+ * // `true` in the `session` parameter
+ * const storage2 = storeBuddy("foo", true).init("bar");
+ *
+ * // Type safety can be enabled by providing an argument to the type parameter
+ * type Data = {
+ *   hello: string;
+ *   world: number;
+ * }
+ *
+ * const storage3 = storeBuddy<Data>("foo").init({
+ *   hello: "foo",
+ *   world: 123
+ * })
+ * ```
+ */
+export function storeBuddy(key, session = false) {
+    return {
+        init(initialData) {
+            const sessionOrLocal = session ? sessionStorage : localStorage;
+            if (sessionOrLocal.getItem(key) === null) {
+                sessionOrLocal.setItem(key, JSON.stringify(initialData));
+            }
+            return {
+                load() {
+                    const raw = sessionOrLocal.getItem(key);
+                    if (raw === null) {
+                        throw new Error('store-buddy: data has not been set or cannot be recognised');
+                    }
+                    const data = JSON.parse(raw);
+                    return data;
+                },
+                save: (data) => {
+                    sessionOrLocal.setItem(key, JSON.stringify(data));
+                },
+                reset: () => {
+                    sessionOrLocal.setItem(key, JSON.stringify(initialData));
+                },
+                clear: () => {
+                    sessionOrLocal.removeItem(key);
+                },
+            };
+        },
+    };
+}

package/dist/lib/utils/time.js

@@ -0,0 +1,13 @@
+export const sleep = async (ms) => {
+    await new Promise((resolve) => setTimeout(resolve, ms));
+};
+const calc = (m) => (n) => Math.round(n * m);
+export const ms = {
+    seconds: calc(1e3),
+    minutes: calc(6e4),
+    hours: calc(36e5),
+    days: calc(864e5),
+    weeks: calc(6048e5),
+    months: calc(26298e5),
+    years: calc(315576e5),
+};

package/dist/lib/worker/md5.js

@@ -0,0 +1,18 @@
+import { workerMd5Script } from './workerCodes.js';
+export async function md5(data) {
+    return await new Promise((resolve, reject) => {
+        const worker = new Worker(URL.createObjectURL(new Blob([workerMd5Script], { type: 'text/javascript' })));
+        worker.addEventListener('error', reject);
+        worker.addEventListener('messageerror', reject);
+        worker.addEventListener('message', ({ data }) => {
+            if (data.event === 'md5-result') {
+                worker.terminate();
+                resolve(data.data);
+            }
+        });
+        worker.postMessage({
+            event: 'md5',
+            data,
+        });
+    });
+}

package/dist/lib/worker/sodium.js

@@ -0,0 +1,95 @@
+import { workerSodiumScript } from './workerCodes.js';
+// const ensureNonDetachedUniqueBuffers = (
+//   values: Transferable[]
+// ): Set<Transferable> =>
+//   new Set(
+//     values.filter(v => {
+//       if (v instanceof ArrayBuffer) {
+//         return v.byteLength === 0;
+//       } else {
+//         return true;
+//       }
+//     })
+//   );
+export async function encrypt(key, dataToEncrypt, progress, signal) {
+    return await new Promise((resolve, reject) => {
+        void progress?.({
+            current: 0,
+            percent: 0,
+            total: dataToEncrypt.byteLength,
+        });
+        const worker = new Worker(URL.createObjectURL(new Blob([workerSodiumScript], { type: 'text/javascript' })));
+        worker.addEventListener('error', reject);
+        worker.addEventListener('messageerror', reject);
+        worker.addEventListener('message', ({ data }) => {
+            switch (data.event) {
+                case 'ready': {
+                    const postData = {
+                        event: 'encrypt',
+                        data: dataToEncrypt,
+                        key,
+                    };
+                    worker.postMessage(postData, {
+                        transfer: [postData.data.buffer],
+                    });
+                    break;
+                }
+                case 'encrypt-progress': {
+                    if (signal?.aborted === true) {
+                        const abortError = new Error('Aborted');
+                        abortError.name = 'AbortError';
+                        worker.terminate();
+                        reject(abortError);
+                    }
+                    void progress?.(data.data);
+                    break;
+                }
+                case 'encrypt-result': {
+                    worker.terminate();
+                    resolve(data.data);
+                }
+            }
+        });
+    });
+}
+export async function decrypt(key, dataToDecrypt, progress, signal) {
+    return await new Promise((resolve, reject) => {
+        void progress?.({
+            current: 0,
+            percent: 0,
+            total: dataToDecrypt.byteLength,
+        });
+        const worker = new Worker(URL.createObjectURL(new Blob([workerSodiumScript], { type: 'text/javascript' })));
+        worker.addEventListener('error', reject);
+        worker.addEventListener('messageerror', reject);
+        worker.addEventListener('message', ({ data }) => {
+            switch (data.event) {
+                case 'ready': {
+                    const postData = {
+                        event: 'decrypt',
+                        key,
+                        data: dataToDecrypt,
+                    };
+                    worker.postMessage(postData, {
+                        transfer: [postData.data.buffer],
+                    });
+                    break;
+                }
+                case 'decrypt-progress': {
+                    if (signal?.aborted === true) {
+                        const abortError = new Error('Aborted');
+                        abortError.name = 'AbortError';
+                        worker.terminate();
+                        reject(abortError);
+                    }
+                    void progress?.(data.data);
+                    break;
+                }
+                case 'decrypt-result': {
+                    worker.terminate();
+                    resolve(data.data);
+                }
+            }
+        });
+    });
+}

package/dist/lib/worker/workerCodes.js

@@ -0,0 +1,254 @@
+export const workerSodiumScript = `let sodium;
+
+self.sodium = {
+  onload: (sod) => {
+    sodium = sod
+    postMessage({ event: "ready" })
+  }
+};
+
+importScripts('https://cdn.jsdelivr.net/gh/jedisct1/libsodium.js@master/dist/browsers/sodium.js');
+importScripts('https://cdnjs.cloudflare.com/ajax/libs/spark-md5/3.0.0/spark-md5.min.js');
+
+function* chunks(arr, n) {
+  for (let i = 0; i < arr.length; i += n) {
+    yield arr.slice(i, i + n);
+  }
+}
+
+function assert(c, message) {
+  if (!c) {
+    throw new Error(message);
+  }
+}
+
+function encrypt(key) {
+  let destroyed = false;
+  const {
+    state,
+    header
+  } = sodium.crypto_secretstream_xchacha20poly1305_init_push(key);
+
+  const encrypt = (tag, plaintext) => {
+    assert(destroyed === false, "state already destroyed");
+
+    return sodium.crypto_secretstream_xchacha20poly1305_push(
+      state,
+      plaintext,
+      null,
+      tag
+    );
+  };
+
+  function destroy() {
+    assert(destroyed === false, "state already destroyed");
+    destroyed = true;
+  }
+
+  return {
+    encrypt,
+    destroy,
+    header
+  };
+}
+
+function decrypt(header, key) {
+  assert(
+    header.byteLength >=
+      sodium.crypto_secretstream_xchacha20poly1305_HEADERBYTES,
+    "header must be at least HEADERBYTES (" + sodium.crypto_secretstream_xchacha20poly1305_HEADERBYTES + ") long"
+  );
+  assert(
+    key.byteLength >= sodium.crypto_secretstream_xchacha20poly1305_KEYBYTES,
+    "key must be at least KEYBYTES (" + sodium.crypto_secretstream_xchacha20poly1305_KEYBYTES + ") long"
+  );
+
+  let destroyed = false;
+  const state = sodium.crypto_secretstream_xchacha20poly1305_init_pull(
+    header,
+    key
+  );
+
+  const decrypt = ciphertext => {
+    assert(destroyed === false, "state already destroyed");
+
+    return sodium.crypto_secretstream_xchacha20poly1305_pull(state, ciphertext);
+  };
+
+  function destroy() {
+    assert(destroyed === false, "state already destroyed");
+    destroyed = true;
+  }
+
+  return {
+    decrypt,
+    destroy
+  };
+}
+
+const CHUNK_SIZE = 8192;
+
+async function encryptSecretstream(key, data, progress) {
+  const { encrypt: crypt, destroy, header } = encrypt(key);
+  const cryptedChunk =
+    CHUNK_SIZE + sodium.crypto_secretstream_xchacha20poly1305_ABYTES;
+  const max =
+    Math.ceil(data.byteLength / CHUNK_SIZE) * cryptedChunk + header.byteLength;
+
+  progress?.({
+    percent: 0,
+    total: max,
+    current: 0
+  });
+  const final = new Uint8Array(max);
+  const sparkEncrypted = new SparkMD5.ArrayBuffer();
+  const spark = new SparkMD5.ArrayBuffer();
+
+  final.set(header);
+  sparkEncrypted.append(header);
+  let total = header.byteLength;
+  progress?.({
+    percent: total / max,
+    total: max,
+    current: total
+  });
+  let lastPercent = total / max;
+
+  for (const chunk of chunks(data, CHUNK_SIZE)) {
+    spark.append(chunk);
+    const tag =
+      chunk.length < CHUNK_SIZE
+        ? sodium.crypto_secretstream_xchacha20poly1305_TAG_FINAL
+        : sodium.crypto_secretstream_xchacha20poly1305_TAG_MESSAGE;
+    const crypted = crypt(tag, chunk);
+    sparkEncrypted.append(crypted);
+    final.set(crypted, total);
+    total += crypted.byteLength;
+    const percent = total / max;
+    if (percent > lastPercent + 0.01) {
+      progress?.({
+        percent,
+        total: max,
+        current: total
+      });
+      lastPercent = percent;
+    }
+  }
+
+  destroy();
+  progress?.({
+    percent: 1,
+    total,
+    current: total
+  });
+  return {
+    data: final.slice(0, total),
+    md5Encrypted: sparkEncrypted.end(),
+    md5: spark.end()
+  };
+}
+
+async function decryptSecretstream(key, data, progress) {
+  const header = data.slice(
+    0,
+    sodium.crypto_secretstream_xchacha20poly1305_HEADERBYTES
+  );
+  data = data.slice(sodium.crypto_secretstream_xchacha20poly1305_HEADERBYTES);
+
+  const { decrypt: decryptt, destroy } = decrypt(header, key);
+  const chunkSize =
+    CHUNK_SIZE + sodium.crypto_secretstream_xchacha20poly1305_ABYTES;
+  const max = Math.ceil(data.byteLength / chunkSize) * CHUNK_SIZE;
+
+  progress?.({
+    percent: 0,
+    total: max,
+    current: 0
+  });
+  const final = new Uint8Array(max);
+  let total = 0;
+  let lastPercent = total / max;
+
+  for (const chunk of chunks(data, chunkSize)) {
+    const tmp = decryptt(chunk);
+    final.set(tmp.message, total);
+    total += tmp.message.byteLength;
+
+    const percent = total / max;
+    if (percent > lastPercent + 0.01) {
+      progress?.({
+        percent,
+        total: max,
+        current: total
+      });
+      lastPercent = percent;
+    }
+  }
+
+  destroy();
+  progress?.({
+    percent: 1,
+    total,
+    current: total
+  });
+  return final.slice(0, total);
+}
+
+self.onmessage = async ({ data }) => {
+  switch (data.event) {
+    case "encrypt": {
+      postMessage({ event: "working" })
+      postMessage({
+        event: "encrypt-result",
+        data: await encryptSecretstream(data.key, data.data, progress => postMessage({
+          event: "encrypt-progress",
+          data: progress
+        }))
+      });
+      postMessage({ event: "ready" })
+      break;
+    }
+    case "decrypt": {
+      postMessage({ event: "working" })
+      postMessage({
+        event: "decrypt-result",
+        data: await decryptSecretstream(data.key, data.data, progress => postMessage({
+          event: "decrypt-progress",
+          data: progress
+        }))
+      });
+      postMessage({ event: "ready" })
+      break;
+    }
+  }
+}`;
+export const workerMd5Script = `importScripts('https://cdnjs.cloudflare.com/ajax/libs/spark-md5/3.0.0/spark-md5.min.js');
+
+function* chunks(arr, n) {
+  for (let i = 0; i < arr.length; i += n) {
+    yield arr.slice(i, i + n);
+  }
+}
+
+const CHUNK_SIZE = 8192;
+
+function md5(data) {
+  const spark = new SparkMD5.ArrayBuffer();
+  for (const chunk of chunks(data, CHUNK_SIZE)) {
+    spark.append(chunk);
+  }
+  return spark.end();
+}
+
+
+self.onmessage = ({ data }) => {
+  switch (data.event) {
+    case "md5": {
+      postMessage({
+        event: "md5-result",
+        data: md5(data.data)
+      });
+      break;
+    }
+  }
+}`;

package/dist/types/base-client.d.ts

@@ -0,0 +1,28 @@
+import { type ApiClient, type RouterOutputs, type RouterInputs } from './client.js';
+import { type InfuraNetwork, type PublicUser } from './index.js';
+import { type SelfUser } from './client/types/user.js';
+export declare class BaseClient {
+    #private;
+    static readonly getBaseClient: (session?: string | null | undefined, onAccessDenied?: () => void) => ApiClient;
+    protected client: ApiClient;
+    sessionId: string;
+    constructor(session: string);
+    logout(sessionId?: string | null | undefined): Promise<void>;
+    me(): Promise<SelfUser>;
+    static getUser(userId: string, sessionId?: string | null | undefined): Promise<PublicUser>;
+    getUser(userId: string): Promise<PublicUser>;
+    searchUsers(search: string): Promise<PublicUser[]>;
+    updateProfile(data: RouterInputs['user']['updateProfile']): Promise<SelfUser>;
+    static isCryptoTransactionDone({ idOrHash, network, }: {
+        idOrHash: string;
+        network?: InfuraNetwork;
+    }): Promise<boolean>;
+    reportUser(data: RouterInputs['report']['create']): Promise<RouterOutputs['report']['create']>;
+    getSponsorshipLink({ backUrl, }: {
+        backUrl: string;
+    }): Promise<string | null>;
+    static getPaymentRequest: ({ paymentRequestId, secrecyIdSeller, }: {
+        paymentRequestId: string;
+        secrecyIdSeller: string;
+    }) => Promise<RouterOutputs['stripe']['paymentRequestToPay']>;
+}

package/dist/types/cache.d.ts

@@ -0,0 +1,11 @@
+import type { InternalNode, InternalFile, InternalNodeFull } from './client/types/index.js';
+export declare const filesCache: Map<string, InternalFile>;
+export declare const nodesCache: Map<string, InternalNode | InternalNodeFull>;
+export declare const usersCache: Map<string, {
+    id: string;
+    lastname: string;
+    firstname: string;
+    avatar: string | null;
+    isSearchable: boolean;
+}>;
+export declare const publicKeysCache: Map<string, string>;

package/dist/types/client/SecrecryCareClient.d.ts

@@ -0,0 +1,9 @@
+import type { SecrecyClient, KeyPair } from '../index.js';
+import type { ApiClient, RouterInputs, RouterOutputs } from '../client.js';
+export declare class SecrecyCareClient {
+    #private;
+    constructor(client: SecrecyClient, keys: KeyPair, apiClient: ApiClient);
+    getProfessional(input: RouterInputs['care']['professional']['get']): Promise<RouterOutputs['care']['professional']['get']>;
+    listProfessionals(input: RouterInputs['care']['professional']['list']): Promise<RouterOutputs['care']['professional']['list']>;
+    registerProfessional(input: RouterInputs['care']['professional']['register']): Promise<RouterOutputs['care']['professional']['register']>;
+}