fauna-api 0.0.0-stage → 1.0.679

package/dist/src/cicada/phone.js

@@ -0,0 +1,306 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _PhoneCall_instances, _PhoneCall_ws, _PhoneCall_statusListeners, _PhoneCall_queue, _PhoneCall_wake, _PhoneCall_closed, _PhoneCall_ended, _PhoneCall_setStatus, _IncomingCall_authorization, _IncomingCall_ringing, _IncomingCall_accepted;
+import { Cicada } from "./index.js";
+import WebSocket from "isomorphic-ws";
+function toBytes(data) {
+    if (data instanceof Uint8Array)
+        return data;
+    if (data instanceof ArrayBuffer)
+        return new Uint8Array(data);
+    if (ArrayBuffer.isView(data))
+        return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+    return new Uint8Array(0);
+}
+function phoneSocket(authorization, path, query = {}) {
+    const base = Cicada.getURL().replace('https://', 'wss://').replace('http://', 'ws://');
+    const params = new URLSearchParams({
+        ...query,
+        authorization: JSON.stringify({
+            Authorization: 'email' in authorization ? `Token ${authorization.token}` : `ApiKey ${authorization.id}`,
+        }),
+    });
+    const ws = new WebSocket(`${base}${path}?${params}`);
+    ws.binaryType = 'arraybuffer';
+    return ws;
+}
+export class PhoneCall {
+    constructor(json, ws) {
+        _PhoneCall_instances.add(this);
+        Object.defineProperty(this, "id", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "direction", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** The linked Twilio number, E.164. */
+        Object.defineProperty(this, "line", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** The other party, E.164. */
+        Object.defineProperty(this, "peer", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "status", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        _PhoneCall_ws.set(this, void 0);
+        _PhoneCall_statusListeners.set(this, new Set());
+        _PhoneCall_queue.set(this, []);
+        _PhoneCall_wake.set(this, void 0);
+        _PhoneCall_closed.set(this, false);
+        _PhoneCall_ended.set(this, void 0);
+        this.id = String(json.id);
+        this.direction = json.direction === 'IN' ? 'IN' : 'OUT';
+        this.line = String(json.line ?? '');
+        this.peer = String(json.peer ?? '');
+        this.status = json.status === 'ACTIVE' ? 'ACTIVE' : json.status === 'ENDED' ? 'ENDED' : 'RINGING';
+        __classPrivateFieldSet(this, _PhoneCall_ws, ws, "f");
+        let finish = () => { };
+        __classPrivateFieldSet(this, _PhoneCall_ended, new Promise((resolve) => { finish = resolve; }), "f");
+        const close = (end) => {
+            if (__classPrivateFieldGet(this, _PhoneCall_closed, "f"))
+                return;
+            __classPrivateFieldGet(this, _PhoneCall_instances, "m", _PhoneCall_setStatus).call(this, 'ENDED');
+            __classPrivateFieldSet(this, _PhoneCall_closed, true, "f");
+            __classPrivateFieldGet(this, _PhoneCall_wake, "f")?.call(this);
+            finish(end);
+        };
+        ws.onmessage = (msg) => {
+            if (typeof msg.data !== 'string') {
+                __classPrivateFieldGet(this, _PhoneCall_queue, "f").push(toBytes(msg.data));
+                __classPrivateFieldGet(this, _PhoneCall_wake, "f")?.call(this);
+                return;
+            }
+            let packet;
+            try {
+                packet = JSON.parse(msg.data);
+            }
+            catch {
+                return;
+            }
+            if (packet.event === 'status') {
+                if (packet.data?.status === 'ACTIVE')
+                    __classPrivateFieldGet(this, _PhoneCall_instances, "m", _PhoneCall_setStatus).call(this, 'ACTIVE');
+            }
+            else if (packet.event === 'ended') {
+                close({ status: packet.data?.status ?? 'COMPLETED', duration: Number(packet.data?.duration ?? 0) });
+                try {
+                    ws.close();
+                }
+                catch { }
+            }
+            else if (packet.event === 'error') {
+                close({ status: 'FAILED', duration: 0 });
+            }
+        };
+        ws.onclose = () => close({ status: this.status === 'ACTIVE' ? 'COMPLETED' : 'FAILED', duration: 0 });
+        ws.onerror = () => close({ status: 'FAILED', duration: 0 });
+    }
+    /** Calls `listener` when the call is answered (ACTIVE) and when it ends (ENDED). */
+    onStatus(listener) {
+        __classPrivateFieldGet(this, _PhoneCall_statusListeners, "f").add(listener);
+        return () => { __classPrivateFieldGet(this, _PhoneCall_statusListeners, "f").delete(listener); };
+    }
+    /** The other party's audio: PCM16 mono 16 kHz, the same as generateVoice's audio input. */
+    async *audio() {
+        for (;;) {
+            const chunk = __classPrivateFieldGet(this, _PhoneCall_queue, "f").shift();
+            if (chunk) {
+                yield chunk;
+                continue;
+            }
+            if (__classPrivateFieldGet(this, _PhoneCall_closed, "f"))
+                return;
+            await new Promise((resolve) => { __classPrivateFieldSet(this, _PhoneCall_wake, resolve, "f"); });
+            __classPrivateFieldSet(this, _PhoneCall_wake, undefined, "f");
+        }
+    }
+    /** Audio to the other party: PCM16 mono 24 kHz, the same as generateVoice's audio output. */
+    send(pcm) {
+        if (__classPrivateFieldGet(this, _PhoneCall_ws, "f").readyState === WebSocket.OPEN)
+            __classPrivateFieldGet(this, _PhoneCall_ws, "f").send(pcm);
+    }
+    async hangup() {
+        if (__classPrivateFieldGet(this, _PhoneCall_ws, "f").readyState === WebSocket.OPEN)
+            __classPrivateFieldGet(this, _PhoneCall_ws, "f").send(JSON.stringify({ event: 'hangup' }));
+        await __classPrivateFieldGet(this, _PhoneCall_ended, "f");
+    }
+    /** Resolves once the call is over. duration is seconds of talk, 0 when never answered. */
+    ended() {
+        return __classPrivateFieldGet(this, _PhoneCall_ended, "f");
+    }
+    static fromJSON(json, ws) {
+        return new PhoneCall(json, ws);
+    }
+}
+_PhoneCall_ws = new WeakMap(), _PhoneCall_statusListeners = new WeakMap(), _PhoneCall_queue = new WeakMap(), _PhoneCall_wake = new WeakMap(), _PhoneCall_closed = new WeakMap(), _PhoneCall_ended = new WeakMap(), _PhoneCall_instances = new WeakSet(), _PhoneCall_setStatus = function _PhoneCall_setStatus(status) {
+    if (this.status === status)
+        return;
+    this.status = status;
+    for (const listener of __classPrivateFieldGet(this, _PhoneCall_statusListeners, "f"))
+        listener(status);
+};
+// Opens a call socket and resolves with the call once the server confirms it.
+function openCall(authorization, first) {
+    const ws = phoneSocket(authorization, '/cicada/phone/call');
+    return new Promise((resolve, reject) => {
+        ws.onopen = () => ws.send(JSON.stringify(first));
+        ws.onerror = () => reject(new Error('Phone connection failed.'));
+        ws.onclose = () => reject(new Error('The call ended before it started.'));
+        ws.onmessage = (msg) => {
+            if (typeof msg.data !== 'string')
+                return;
+            let packet;
+            try {
+                packet = JSON.parse(msg.data);
+            }
+            catch {
+                return;
+            }
+            if (packet.event === 'call') {
+                resolve(PhoneCall.fromJSON(packet.data, ws));
+            }
+            else if (packet.event === 'error') {
+                reject(new Error(packet.message ?? 'The call failed.'));
+                try {
+                    ws.close();
+                }
+                catch { }
+            }
+        };
+    });
+}
+// How listen() tells an IncomingCall it stopped ringing.
+const ringEnders = new WeakMap();
+export class IncomingCall {
+    constructor(json, authorization) {
+        Object.defineProperty(this, "id", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** The inbox's number that was called. */
+        Object.defineProperty(this, "line", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** Who is calling. */
+        Object.defineProperty(this, "peer", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        _IncomingCall_authorization.set(this, void 0);
+        _IncomingCall_ringing.set(this, void 0);
+        _IncomingCall_accepted.set(this, false);
+        this.id = String(json.id);
+        this.line = String(json.line ?? '');
+        this.peer = String(json.peer ?? '');
+        __classPrivateFieldSet(this, _IncomingCall_authorization, authorization, "f");
+        let end = () => { };
+        __classPrivateFieldSet(this, _IncomingCall_ringing, new Promise((resolve) => { end = resolve; }), "f");
+        ringEnders.set(this, (reason) => end(__classPrivateFieldGet(this, _IncomingCall_accepted, "f") ? 'ACCEPTED' : reason));
+    }
+    /** Rejects with "Someone else took the call." when another listener won. */
+    async accept() {
+        const call = await openCall(__classPrivateFieldGet(this, _IncomingCall_authorization, "f"), { event: 'answer', id: this.id });
+        __classPrivateFieldSet(this, _IncomingCall_accepted, true, "f");
+        ringEnders.get(this)?.('ACCEPTED');
+        return call;
+    }
+    /** Resolves when it stops ringing for you. */
+    ringing() {
+        return __classPrivateFieldGet(this, _IncomingCall_ringing, "f");
+    }
+    static fromJSON(json, authorization) {
+        return new IncomingCall(json, authorization);
+    }
+}
+_IncomingCall_authorization = new WeakMap(), _IncomingCall_ringing = new WeakMap(), _IncomingCall_accepted = new WeakMap();
+/** Rings for calls to any Twilio number linked to the inbox, until close(). */
+export async function listen(authorization, inbox, onIncoming) {
+    const ws = phoneSocket(authorization, '/cicada/phone/listen', { inbox });
+    const ringing = new Map();
+    await new Promise((resolve, reject) => {
+        ws.onerror = () => reject(new Error('Phone connection failed.'));
+        ws.onclose = () => reject(new Error('Phone connection closed.'));
+        ws.onmessage = (msg) => {
+            if (typeof msg.data !== 'string')
+                return;
+            let packet;
+            try {
+                packet = JSON.parse(msg.data);
+            }
+            catch {
+                return;
+            }
+            if (packet.event === 'listening') {
+                resolve();
+            }
+            else if (packet.event === 'error') {
+                reject(new Error(packet.message ?? 'Could not listen for calls.'));
+            }
+            else if (packet.event === 'incoming') {
+                const call = IncomingCall.fromJSON(packet.data, authorization);
+                ringing.set(call.id, call);
+                onIncoming(call);
+            }
+            else if (packet.event === 'ring-end') {
+                const call = ringing.get(String(packet.data?.id));
+                if (!call)
+                    return;
+                ringing.delete(call.id);
+                ringEnders.get(call)?.(packet.data?.reason ?? 'HUNG_UP');
+            }
+        };
+    });
+    const endAll = () => {
+        for (const call of ringing.values())
+            ringEnders.get(call)?.('HUNG_UP');
+        ringing.clear();
+    };
+    ws.onclose = endAll;
+    ws.onerror = endAll;
+    return {
+        close() {
+            endAll();
+            try {
+                ws.close();
+            }
+            catch { }
+        },
+    };
+}
+/** Calls `to` from one of the inbox's phone lines: `from`, or its first line. */
+export async function call(authorization, inbox, to, from) {
+    return openCall(authorization, { event: 'dial', inbox, to, ...(from ? { from } : {}) });
+}

package/dist/src/drive.d.ts

@@ -0,0 +1,80 @@
+import { ApiKey, Credentials } from "./authentification.js";
+export { FaunaFile as File };
+declare class FaunaFile {
+    readonly authorization: DriveAuthorization;
+    readonly contentType: string;
+    readonly contentLength: number;
+    readonly accessDate: Date;
+    readonly createDate: Date;
+    private _name;
+    get name(): string;
+    private _online;
+    get online(): boolean;
+    constructor(authorization: DriveAuthorization, name: string, online: boolean, contentType: string, contentLength: number, accessDate: Date, createDate: Date, data?: Uint8Array | undefined);
+    static fromJSON(json: any, authorization: DriveAuthorization): FaunaFile;
+    private data;
+    private previewData;
+    download(revalidate?: boolean, onProgress?: (percent: number) => void): Promise<Uint8Array>;
+    preview(revalidate?: boolean): Promise<Uint8Array | undefined>;
+    upload(onProgress?: (percent: number) => void): Promise<void>;
+    copy(path: string): Promise<void>;
+    text(): Promise<string>;
+    json<T>(): Promise<T>;
+    remove(): Promise<void>;
+    generateAccessCode(expiration?: number): Promise<string>;
+    owner(): Promise<{
+        email: string;
+        displayName?: string;
+        icon?: string;
+    }>;
+}
+export type DriveAuthorization = {
+    authorization: Credentials | ApiKey;
+    path: string;
+    group?: string;
+} | {
+    authorization: Credentials | ApiKey;
+    accessCode: string;
+} | {
+    authorization: Credentials | ApiKey;
+    repository: number;
+    path: string;
+    group?: string;
+};
+export declare function list(authorization: Credentials | ApiKey, path: string, group?: string): Promise<string[]>;
+export declare function wrap(authorization: DriveAuthorization, file: File, options?: Partial<{
+    accessDate: Date;
+    createDate: Date;
+}>): Promise<FaunaFile>;
+/**
+ * Build an in-memory FaunaFile from raw bytes (not yet uploaded). `path` is
+ * the Drive destination (e.g. `tmp/${uuid}-${name}`); the display name is the
+ * last path segment. `authorization` is the caller's credentials/api key; the
+ * file is `online: false` until an explicit `upload()`.
+ */
+export declare function fromBytes(authorization: Credentials | ApiKey, path: string, contentType: string, data: Uint8Array, options?: Partial<{
+    accessDate: Date;
+    createDate: Date;
+}>): FaunaFile;
+/**
+ * Build a streaming FaunaFile addressed by a per-file access code. Bytes are
+ * pulled on demand via `download()` (the `Access-Code` path). Used to hydrate
+ * chat message FILE parts returned by the server (each carries its own code),
+ * so members stream file bytes uniformly without a host-drive path.
+ */
+export declare function fromAccessCode(authorization: Credentials | ApiKey, accessCode: string, meta: {
+    name: string;
+    contentType: string;
+    contentLength?: number;
+    accessDate?: Date;
+    createDate?: Date;
+}): FaunaFile;
+export declare function folder(authorization: DriveAuthorization, options?: Partial<{
+    accessDate: Date;
+    createDate: Date;
+}>): Promise<FaunaFile>;
+export declare function pull(authorization: DriveAuthorization): Promise<FaunaFile>;
+export declare function remove(authorization: Credentials | ApiKey, path: string, group?: string): Promise<boolean>;
+/** Split a Drive style response into its parts. With `Encoding-Size` above 1 the
+ *  body is a `--BOUNDARY` separated multipart and this returns every part. */
+export declare function parseStream(response: Response, onLoaded?: (loadedBytes: number) => void): Promise<Uint8Array<ArrayBuffer> | Uint8Array<ArrayBufferLike>[]>;