@fkn/lib 0.0.2 → 0.1.0

package/README.md

@@ -4,3 +4,5 @@
 
 ## TODOs:
 - make docs using vitepress
+- Allow multiple origins to access the same data by having a public/private key pair sign the origin it's served from
+  e.g, anime.fkn.app hashes gives access to the same public key verif that fc7zsi85kboht4mj5.npm.fkn.sdbx.app has

package/build/api.d.ts

@@ -1,4 +1,4 @@
-import type { Target } from 'osra';
-export declare const setApiTarget: (messagePort: Target | Promise<Target>) => Promise<void>;
-export declare const apiTargetIsReady: () => Promise<Target>;
-export declare const getApiTargetPort: () => Promise<any>;
+import type { Target } from 'osra';
+export declare const setApiTarget: (messagePort: Target | Promise<Target>) => Promise<void>;
+export declare const apiTargetIsReady: () => Promise<Target>;
+export declare const getApiTargetPort: () => Promise<any>;

package/build/dom.d.ts

@@ -1,5 +1,3 @@
-export declare const isWorker: boolean;
-export declare const createdIframe: HTMLIFrameElement;
-export declare const foundIframe: HTMLIFrameElement;
-export declare const iframe: HTMLIFrameElement;
-export declare const targetWindow: Window | null;
+export declare const isWorker: boolean;
+export declare const iframe: HTMLIFrameElement;
+export declare const targetWindow: Window | null;

package/build/index.d.ts

@@ -1,3 +1,3 @@
-export { serverProxyFetch } from './proxy';
-export { torrent, torrentFile } from './torrent';
-export { setApiTarget, apiTargetIsReady as getApiTarget, getApiTargetPort } from './api';
+export { serverProxyFetch } from './proxy';
+export { WebVPNWebTransport } from './webvpn';
+export { setApiTarget, apiTargetIsReady as getApiTarget, getApiTargetPort } from './api';

package/build/index.js

@@ -1,71 +1,127 @@
-import { call as d } from "osra";
-let h, a;
-const f = () => (a = new Promise((e, t) => {
-  h = e;
-}), a), y = f(), m = async (e) => {
-  e === y && f(), h(await e);
-}, g = "https://fkn.app", T = globalThis.window === void 0, r = globalThis.document?.createElement("iframe");
-r && (r.src = `${g}/sandbox-api`, r.style.display = "none", document.body.appendChild(r));
-const c = r, p = c?.contentWindow, b = (e) => m(e), w = () => a, k = async () => d(await w(), { key: "fkn-sandbox-api" })("API_PORT", {});
-if (T) {
-  let e = !1;
-  a.then(() => {
-    e = !0;
+import { call as g } from "osra";
+let c, i;
+const d = () => (i = new Promise((t, e) => {
+  c = t;
+}), i), p = d(), m = async (t) => {
+  t === p && d(), c(await t);
+}, h = "https://fkn.app", f = globalThis.window === void 0, o = globalThis?.document.querySelector(`iframe[src="${h}/sandbox-api"]`), n = globalThis.document?.createElement("iframe");
+!o && n && (n.src = `${h}/sandbox-api`, n.style.display = "none", document.body.appendChild(n));
+const w = o || n, l = w?.contentWindow, b = (t) => m(t), u = () => i, x = async () => g(await u(), { key: "fkn-sandbox-api" })("API_PORT", {});
+if (f) {
+  let t = !1;
+  i.then(() => {
+    t = !0;
   }), setTimeout(() => {
-    e || console.warn("@fkn/lib's api target has not resolved after 250ms while in a worker, make sure to call `setApiTarget(messagePort)`");
+    t || console.warn("@fkn/lib's api target has not resolved after 250ms while in a worker, make sure to call `setApiTarget(messagePort)`");
   }, 250);
 } else {
-  if (!c)
+  if (!w)
     throw new Error("Missing appended iframe");
-  c.addEventListener("load", () => {
-    const e = setInterval(
-      () => d(p, { key: "fkn-sandbox" })("APP_READY", {}).then(() => {
-        m(p), clearInterval(e);
-      }),
-      10
-    );
-  });
+  const t = setInterval(
+    () => g(l, { key: "fkn-sandbox" })("APP_READY", {}).then(() => {
+      m(l), clearInterval(t);
+    }).catch(() => {
+      console.warn("Failed to connect to sandbox, trying again in 10ms");
+    }),
+    10
+  );
 }
-const l = (e, t) => w().then(
-  (s) => d(s, { key: "fkn-sandbox-api" })(e, t)
-), E = async (e, t) => {
-  const s = e, o = t, { body: i, ...n } = await l("SERVER_PROXY_FETCH", { input: s, init: o });
+const _ = (t, e) => u().then(
+  (a) => g(a, { key: "fkn-sandbox-api" })(t, e)
+), y = async (t, e) => {
+  const a = t, s = e, { body: I, ...r } = await _("SERVER_PROXY_FETCH", { input: a, init: s });
   return new Response(
-    i,
+    I,
     {
-      ...n,
+      ...r,
       headers: {
-        ...n.headers,
-        ...n.headers && {
-          setCookie: n.headers["set-cookie"]
+        ...r.headers,
+        ...r.headers && {
+          setCookie: r.headers["set-cookie"]
         }
       }
     }
   );
-}, P = async ({ magnet: e, path: t, offset: s, end: o }) => {
-  const { body: i, ...n } = await l("TORRENT", { magnet: e, path: t, offset: s, end: o });
-  return new Response(
-    i,
-    {
-      ...n,
-      headers: Object.fromEntries(n.headers)
-    }
-  );
-}, u = async ({ magnet: e }) => {
-  const { body: t, ...s } = await l("TORRENT_FILE", { magnet: e });
-  return new Response(
-    t,
-    {
-      ...s,
-      headers: Object.fromEntries(s.headers)
-    }
-  );
 };
+class M {
+  _internals;
+  _awaitedInternals;
+  closed;
+  constructor() {
+    this.closed = new Promise((e) => {
+      this._internals = _(
+        "WEBVPN_WEBTRANSPORT",
+        {
+          close: ({ closeCode: a, reason: s }) => e({ closeCode: a, reason: s })
+        }
+      ), this._internals.then((a) => {
+        this._awaitedInternals = a;
+      });
+    });
+  }
+  close(e) {
+    this._internals.then(({ close: a }) => a(e ?? {}));
+  }
+  get ready() {
+    return this._internals.then(() => {
+    });
+  }
+  get incomingBidirectionalStreams() {
+    return this._awaitedInternals.incomingBidirectionalStreams;
+  }
+  get incomingUnidirectionalStreams() {
+    return this._awaitedInternals.incomingUnidirectionalStreams;
+  }
+  async createBidirectionalStream() {
+    const { readable: e, writable: a } = await this._awaitedInternals.createBidirectionalStream();
+    return { readable: e, writable: a };
+  }
+  createUnidirectionalStream() {
+    return this._awaitedInternals.createUnidirectionalStream();
+  }
+  get datagrams() {
+    const e = this;
+    return {
+      get incomingHighWaterMark() {
+        return e._awaitedInternals.datagrams.incomingHighWaterMark;
+      },
+      set incomingHighWaterMark(a) {
+        e._awaitedInternals.datagrams.setIncomingHighWaterMark(a);
+      },
+      get incomingMaxAge() {
+        return e._awaitedInternals.datagrams.incomingMaxAge;
+      },
+      set incomingMaxAge(a) {
+        e._awaitedInternals.datagrams.setIncomingMaxAge(a);
+      },
+      get maxDatagramSize() {
+        return e._awaitedInternals.datagrams.maxDatagramSize;
+      },
+      get outgoingHighWaterMark() {
+        return e._awaitedInternals.datagrams.outgoingHighWaterMark;
+      },
+      set outgoingHighWaterMark(a) {
+        e._awaitedInternals.datagrams.setOutgoingHighWaterMark(a);
+      },
+      get outgoingMaxAge() {
+        return e._awaitedInternals.datagrams.outgoingMaxAge;
+      },
+      set outgoingMaxAge(a) {
+        e._awaitedInternals.datagrams.setOutgoingMaxAge(a);
+      },
+      get readable() {
+        return e._awaitedInternals.datagrams.readable;
+      },
+      get writable() {
+        return e._awaitedInternals.datagrams.writable;
+      }
+    };
+  }
+}
 export {
-  w as getApiTarget,
-  k as getApiTargetPort,
-  E as serverProxyFetch,
-  b as setApiTarget,
-  P as torrent,
-  u as torrentFile
+  M as WebVPNWebTransport,
+  u as getApiTarget,
+  x as getApiTargetPort,
+  y as serverProxyFetch,
+  b as setApiTarget
 };

package/build/plugin/index.d.ts

@@ -1 +1 @@
-export declare const showPluginBrowser: () => Promise<any>;
+export declare const showPluginBrowser: () => Promise<any>;

package/build/proxy.d.ts

@@ -1,13 +1,13 @@
-export type NativeFetch = typeof globalThis.fetch;
-export type ProxyFetchRequestInit = Omit<RequestInit, "body" | "headers" | "signal"> & {
-    body: Exclude<RequestInit['body'], FormData | URLSearchParams>;
-    headers: Exclude<RequestInit['headers'], Headers>;
-};
-export type FetchInitOptions = {
-    proxyCache?: string | undefined;
-    proxyDelay?: string | undefined;
-    proxyRuntime?: boolean | undefined;
-    noProxy?: boolean | undefined;
-};
-export type ProxyFetchRequestInfo = string | Omit<Request, "arrayBuffer" | "text" | "headers" | "signal" | "clone" | "blob" | "formData" | "json">;
-export declare const serverProxyFetch: (_input: Parameters<NativeFetch>[0], _init?: Parameters<NativeFetch>[1]) => Promise<Response>;
+export type NativeFetch = typeof globalThis.fetch;
+export type ProxyFetchRequestInit = Omit<RequestInit, "body" | "headers" | "signal"> & {
+    body: Exclude<RequestInit['body'], FormData | URLSearchParams>;
+    headers: Exclude<RequestInit['headers'], Headers>;
+};
+export type FetchInitOptions = {
+    proxyCache?: string | undefined;
+    proxyDelay?: string | undefined;
+    proxyRuntime?: boolean | undefined;
+    noProxy?: boolean | undefined;
+};
+export type ProxyFetchRequestInfo = string | Omit<Request, "arrayBuffer" | "text" | "headers" | "signal" | "clone" | "blob" | "formData" | "json">;
+export declare const serverProxyFetch: (_input: Parameters<NativeFetch>[0], _init?: Parameters<NativeFetch>[1]) => Promise<Response>;

package/build/target.d.ts

@@ -1,6 +1,6 @@
-import { Target } from 'osra';
-export declare let _resolve: any, _reject: any;
-export declare let target: Promise<Target>;
-export declare const initTargetPromise: () => Promise<Target>;
-export declare const initialTargetPromise: Promise<Target>;
-export declare const setTarget: (newTarget: Target | Promise<Target>) => Promise<void>;
+import { Target } from 'osra';
+export declare let _resolve: any, _reject: any;
+export declare let target: Promise<Target>;
+export declare const initTargetPromise: () => Promise<Target>;
+export declare const initialTargetPromise: Promise<Target>;
+export declare const setTarget: (newTarget: Target | Promise<Target>) => Promise<void>;

package/build/utils/call.d.ts

@@ -1,2 +1,3 @@
-declare const readyCall: <T2 extends SandboxApiResolvers, T3 extends keyof T2>(type: T3, data?: Parameters<T2[T3]>[0] | undefined) => Promise<any>;
-export { readyCall as call, };
+import type { SandboxApiResolvers } from '@mfkn/fkn-web/src/api/resolvers';
+declare const readyCall: <T2 extends SandboxApiResolvers, T3 extends keyof T2>(type: T3, data?: Parameters<T2[T3]>[0] | undefined) => Promise<any>;
+export { readyCall as call, };

package/build/utils/index.d.ts

@@ -1 +1 @@
-export * from './call';
+export * from './call';

package/build/webextension/declarativeNetRequest.d.ts

@@ -1 +1 @@
-export {};
+export {};

package/build/webextension/index.d.ts

@@ -1 +1 @@
-export {};
+export {};

package/build/webvpn/index.d.ts

@@ -0,0 +1,52 @@
+type WebVPNWebTransportResponse = {
+    ready: undefined;
+    close: ({ closeCode, reason }: {
+        closeCode?: number;
+        reason?: string;
+    }) => void;
+    incomingBidirectionalStreams: ReadableStream<any>;
+    incomingUnidirectionalStreams: ReadableStream<any>;
+    createBidirectionalStream: () => Promise<{
+        readable: ReadableStream<any>;
+        writable: WritableStream<any>;
+    }>;
+    createUnidirectionalStream: () => Promise<WritableStream<any>>;
+    datagrams: {
+        incomingHighWaterMark: number;
+        setIncomingHighWaterMark: (value: number) => void;
+        incomingMaxAge: number;
+        setIncomingMaxAge: (value: number) => void;
+        maxDatagramSize: number;
+        outgoingHighWaterMark: number;
+        setOutgoingHighWaterMark: (value: number) => void;
+        outgoingMaxAge: number;
+        setOutgoingMaxAge: (value: number) => void;
+        readable: ReadableStream<any>;
+        writable: WritableStream<any>;
+    };
+};
+export declare class WebVPNWebTransport implements WebTransport {
+    _internals: Promise<WebVPNWebTransportResponse>;
+    _awaitedInternals: WebVPNWebTransportResponse;
+    closed: Promise<WebTransportCloseInfo>;
+    constructor();
+    close(closeInfo?: WebTransportCloseInfo): void;
+    get ready(): Promise<undefined>;
+    get incomingBidirectionalStreams(): ReadableStream<any>;
+    get incomingUnidirectionalStreams(): ReadableStream<any>;
+    createBidirectionalStream(): Promise<{
+        readable: ReadableStream<any>;
+        writable: WritableStream<any>;
+    }>;
+    createUnidirectionalStream(): Promise<WritableStream<any>>;
+    get datagrams(): {
+        incomingHighWaterMark: number;
+        incomingMaxAge: number;
+        readonly maxDatagramSize: number;
+        outgoingHighWaterMark: number;
+        outgoingMaxAge: number;
+        readonly readable: ReadableStream<any>;
+        readonly writable: WritableStream<any>;
+    };
+}
+export {};

package/package.json

@@ -1,22 +1,25 @@
 {
   "name": "@fkn/lib",
-  "version": "0.0.2",
+  "version": "0.1.0",
   "main": "build/index.js",
   "types": "build/index.d.ts",
   "type": "module",
-  "files": ["build"],
+  "files": [
+    "build"
+  ],
   "devDependencies": {
     "@mfkn/web": "file:../web",
     "@mfkn/web-extension": "git+https://github.com/MFKN/web-extension.git",
     "concurrently": "^7.6.0",
     "parse-torrent-file": "^4.2.2",
-    "typescript": "^4.9.3",
+    "typescript": "^5.5.4",
     "vite": "^3.2.5",
     "webextension-polyfill": "^0.10.0"
   },
   "scripts": {
     "dev": "concurrently \"vite build --watch --mode development\" \"tsc --watch\"",
     "build": "vite build && tsc",
+    "build-watch": "vite build --watch --mode production && tsc",
     "build-dev": "vite build --mode development && tsc",
     "dev-watch": "vite build --watch --mode development",
     "build-types": "tsc"

package/build/torrent/index.d.ts

@@ -1,10 +0,0 @@
-export type TorrentOptions = {
-    magnet: string;
-    path: string;
-    offset?: number;
-    end?: number;
-};
-export declare const torrent: ({ magnet, path, offset, end }: TorrentOptions) => Promise<Response>;
-export declare const torrentFile: ({ magnet }: {
-    magnet: string;
-}) => Promise<Response>;