@otonoma/paracord-panels-interface 0.17.1-rc.12

package/dist/channel.d.ts

@@ -0,0 +1,14 @@
+import { PanelMessage, MessageBody } from "./interface";
+export declare class Channel {
+    private panelId;
+    private port;
+    evs: Map<number, (data: any) => void>;
+    evId: number;
+    constructor(panelId: string, port: MessagePort, incoming: (msg: PanelMessage) => void);
+    private send;
+    asyncSend(body: MessageBody): Promise<MessageBody>;
+    createStream<T, R>(type: string, msg: T): Promise<Stream<R>>;
+}
+export declare class Stream<R> {
+}
+//# sourceMappingURL=channel.d.ts.map

package/dist/channel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"channel.d.ts","sourceRoot":"","sources":["../src/channel.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAExD,qBAAa,OAAO;IAIhB,OAAO,CAAC,OAAO;IACf,OAAO,CAAC,IAAI;IAJd,GAAG,EAAE,GAAG,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,GAAG,KAAK,IAAI,CAAC,CAAC;IACtC,IAAI,EAAE,MAAM,CAAC;gBAEH,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,WAAW,EACzB,QAAQ,EAAE,CAAC,GAAG,EAAE,YAAY,KAAK,IAAI;IAsBvC,OAAO,CAAC,IAAI;IAgBL,SAAS,CAAC,IAAI,EAAE,WAAW,GAAG,OAAO,CAAC,WAAW,CAAC;IAK5C,YAAY,CAAC,CAAC,EAAE,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;CAG1E;AAED,qBAAa,MAAM,CAAC,CAAC;CAAI"}

package/dist/channel.js

@@ -0,0 +1,46 @@
+import { PARACORD_PANEL_REVISION } from "./interface";
+export class Channel {
+    constructor(panelId, port, incoming) {
+        this.panelId = panelId;
+        this.port = port;
+        this.evs = new Map();
+        this.evId = 0;
+        port.onmessage = (ev) => {
+            const message = ev.data;
+            if (message.messageId === undefined) {
+                // In this case we need to pass the full message so type disambigation can occur on the other side.
+                incoming(message);
+            }
+            else {
+                const cb = this.evs.get(message.messageId);
+                this.evs.delete(message.messageId);
+                if (cb) {
+                    // In this case we can destructure the message.
+                    cb(message.body);
+                }
+            }
+        };
+    }
+    // TODO (JAB): Figure out the "continuous" callbacks; observers, skill callbacks, etc. need to be able to
+    // receive messages repeatedly.
+    send(body, cb, transferred) {
+        const id = this.evId++;
+        this.evs.set(id, cb);
+        const message = {
+            messageId: id,
+            body: body,
+            panelId: this.panelId,
+            apiRevision: PARACORD_PANEL_REVISION,
+        };
+        this.port.postMessage(message, transferred || []);
+    }
+    asyncSend(body) {
+        const p = new Promise((r) => this.send(body, (m) => r(m)));
+        return p;
+    }
+    async createStream(type, msg) {
+        throw new Error("Unimplemented");
+    }
+}
+export class Stream {
+}

package/dist/client/abstractClient.d.ts

@@ -0,0 +1,27 @@
+import { DocumentArgs, LoginCredentials, ObservationCallbackObject, PncpMessageCallbackObject, PncpMessageObject, PncpRequestCallbackObject, SkillRequest } from "@otonoma/paranet-client";
+import { FetchDocumentResponse, GraphqlCallArgs, GraphqlCallResponse, PncpCallResponse, PncpMessageResponse, RegisterObserverCallback, RegisterObserverResponse, RegisterSkillCallback, UploadDocumentArgs, UploadDocumentResponse } from "../interface";
+export interface PncpClientInit {
+    skill?: (msg: PncpRequestCallbackObject) => void;
+    msg?: (msg: PncpMessageCallbackObject) => void;
+    obs?: (msg: ObservationCallbackObject, callback?: any) => void;
+}
+export declare abstract class AbstractPncpClient {
+    skillCb?: (msg: PncpRequestCallbackObject) => void;
+    msgCb?: (msg: PncpMessageCallbackObject) => void;
+    obsCb?: (msg: ObservationCallbackObject, callback?: any) => void;
+    constructor(init?: PncpClientInit);
+    abstract login(creds: LoginCredentials): Promise<void>;
+    abstract pncpRequest(req: SkillRequest): Promise<PncpCallResponse>;
+    abstract pncpResponse(req: PncpMessageResponse): Promise<PncpCallResponse>;
+    abstract pncpMessage(req: PncpMessageObject): Promise<PncpCallResponse>;
+    abstract registerSkillCallback(req: RegisterSkillCallback): any;
+    abstract registerObserverCallback(req: RegisterObserverCallback): Promise<RegisterObserverResponse>;
+    abstract deleteObserver(key: string): Promise<void>;
+    skillCallback(cb: (msg: PncpRequestCallbackObject) => void): this;
+    messageCallback(cb: (msg: PncpMessageCallbackObject) => void): this;
+    observationCallback(cb: (msg: ObservationCallbackObject, callback?: any) => void): this;
+    abstract uploadDocument(args: UploadDocumentArgs): Promise<UploadDocumentResponse>;
+    abstract fetchDocument(args: DocumentArgs): Promise<FetchDocumentResponse>;
+    abstract graphqlCall(args: GraphqlCallArgs): Promise<GraphqlCallResponse>;
+}
+//# sourceMappingURL=abstractClient.d.ts.map

package/dist/client/abstractClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"abstractClient.d.ts","sourceRoot":"","sources":["../../src/client/abstractClient.ts"],"names":[],"mappings":"AACA,OAAO,EACL,YAAY,EAAE,gBAAgB,EAAE,yBAAyB,EAAE,yBAAyB,EAAE,iBAAiB,EAAE,yBAAyB,EAAE,YAAY,EACjJ,MAAM,yBAAyB,CAAC;AACjC,OAAO,EACL,qBAAqB,EAAE,eAAe,EAAE,mBAAmB,EAAE,gBAAgB,EAAE,mBAAmB,EAAE,wBAAwB,EAAE,wBAAwB,EAAE,qBAAqB,EAAE,kBAAkB,EAAE,sBAAsB,EAC1N,MAAM,cAAc,CAAC;AAEtB,MAAM,WAAW,cAAc;IAC7B,KAAK,CAAC,EAAE,CAAC,GAAG,EAAE,yBAAyB,KAAK,IAAI,CAAC;IACjD,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,yBAAyB,KAAK,IAAI,CAAC;IAC/C,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,yBAAyB,EAAE,QAAQ,CAAC,EAAE,GAAG,KAAK,IAAI,CAAC;CAChE;AAID,8BAAsB,kBAAkB;IACtC,OAAO,CAAC,EAAE,CAAC,GAAG,EAAE,yBAAyB,KAAK,IAAI,CAAC;IACnD,KAAK,CAAC,EAAE,CAAC,GAAG,EAAE,yBAAyB,KAAK,IAAI,CAAC;IACjD,KAAK,CAAC,EAAE,CAAC,GAAG,EAAE,yBAAyB,EAAE,QAAQ,CAAC,EAAE,GAAG,KAAK,IAAI,CAAC;gBACrD,IAAI,CAAC,EAAE,cAAc;aAMjB,KAAK,CAAC,KAAK,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC;aAC7C,WAAW,CAAC,GAAG,EAAE,YAAY,GAAG,OAAO,CAAC,gBAAgB,CAAC;aACzD,YAAY,CAC1B,GAAG,EAAE,mBAAmB,GACvB,OAAO,CAAC,gBAAgB,CAAC;aAEZ,WAAW,CACzB,GAAG,EAAE,iBAAiB,GACrB,OAAO,CAAC,gBAAgB,CAAC;aAGZ,qBAAqB,CAAC,GAAG,EAAE,qBAAqB,GAAG,GAAG;aACtD,wBAAwB,CAAC,GAAG,EAAE,wBAAwB,GAAG,OAAO,CAAC,wBAAwB,CAAC;aAC1F,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAGnD,aAAa,CAAC,EAAE,EAAE,CAAC,GAAG,EAAE,yBAAyB,KAAK,IAAI,GAAG,IAAI;IAKjE,eAAe,CAAC,EAAE,EAAE,CAAC,GAAG,EAAE,yBAAyB,KAAK,IAAI,GAAG,IAAI;IAKnE,mBAAmB,CACxB,EAAE,EAAE,CAAC,GAAG,EAAE,yBAAyB,EAAE,QAAQ,CAAC,EAAE,GAAG,KAAK,IAAI,GAC3D,IAAI;aAKS,cAAc,CAAC,IAAI,EAAE,kBAAkB,GAAG,OAAO,CAAC,sBAAsB,CAAC;aACzE,aAAa,CAAC,IAAI,EAAE,YAAY,GAAG,OAAO,CAAC,qBAAqB,CAAC;aACjE,WAAW,CAAC,IAAI,EAAE,eAAe,GAAG,OAAO,CAAC,mBAAmB,CAAC;CACjF"}

package/dist/client/abstractClient.js

@@ -0,0 +1,22 @@
+// TODO: Make a better name for this
+// This client represents an abstract wrapper around a managed pncp client.
+export class AbstractPncpClient {
+    constructor(init) {
+        this.skillCb = init?.skill;
+        this.msgCb = init?.msg;
+        this.obsCb = init?.obs;
+    }
+    // Set the callback on the local listener for skills.
+    skillCallback(cb) {
+        this.skillCb = cb;
+        return this;
+    }
+    messageCallback(cb) {
+        this.msgCb = cb;
+        return this;
+    }
+    observationCallback(cb) {
+        this.obsCb = cb;
+        return this;
+    }
+}

package/dist/client/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./abstractClient";
+export * from "./paracordClient";
+export * from "./managedPncpClient";
+export * from "./pncpClient";
+export declare function isInParacord(): boolean;
+//# sourceMappingURL=index.d.ts.map

package/dist/client/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/client/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAC;AACjC,cAAc,kBAAkB,CAAC;AACjC,cAAc,qBAAqB,CAAC;AACpC,cAAc,cAAc,CAAC;AAK7B,wBAAgB,YAAY,IAAI,OAAO,CAStC"}

package/dist/client/index.js

@@ -0,0 +1,18 @@
+export * from "./abstractClient";
+export * from "./paracordClient";
+export * from "./managedPncpClient";
+export * from "./pncpClient";
+// A function which determines if the application is currently running inside of a paracord panel or as a standalone app.
+// This can be used to present a login page and construct a direct connection as needed for standalone apps and otherwise
+// establish a ParacordClient.
+export function isInParacord() {
+    // This isn't a guaranteed way to check this, we could achieve that by creating a different encoding of the name though.
+    if (window.top !== window.self) {
+        const name = window.name;
+        const parts = name.split('@');
+        return parts.length == 3 && parts[0].match(/[a-f0-9]*-[a-f0-9]*/) != null;
+    }
+    else {
+        return false;
+    }
+}

package/dist/client/managedPncpClient.d.ts

@@ -0,0 +1,38 @@
+import { AbstractPncpClient, PncpCallResponse, RegisterObserverCallback, RegisterSkillCallback } from "../";
+import { ObservationCallbackObject, PncpMessageCallbackObject, SkillRequest, PncpRequestCallbackObject, PncpQuestionMessage, PncpAnswerMessage } from "@otonoma/paranet-client";
+import AsyncQueue from "@ai-zen/async-queue";
+export declare class ManagedPncpClient {
+    private convs;
+    private convStreams;
+    private observs;
+    private skills;
+    private id;
+    client: AbstractPncpClient;
+    constructor(base: AbstractPncpClient);
+    sendRequest(req: SkillRequest): Promise<ConversationResponse>;
+    createConversation(req: SkillRequest): Promise<ConversationHandler>;
+    createObserver(obs: RegisterObserverCallback, cb: (msg: ObservationCallbackObject) => void): Promise<ObserverHandle>;
+    deleteObserver(id: number, key: string): Promise<void>;
+    createSkillCallback(sk: RegisterSkillCallback, cb: (msg: PncpRequestCallbackObject) => void): Promise<number>;
+}
+export interface ConversationResponse {
+    reply: PncpCallResponse;
+    pncp: PncpMessageCallbackObject;
+}
+export declare class ConversationHandler {
+    private queue;
+    private id;
+    private client;
+    constructor(client: ManagedPncpClient, queue: AsyncQueue<PncpMessageCallbackObject>, reply: PncpCallResponse);
+    next(): Promise<PncpMessageCallbackObject | null>;
+    sendQuestion(req: PncpQuestionMessage): Promise<PncpCallResponse>;
+    sendAnswer(req: PncpAnswerMessage): Promise<PncpCallResponse>;
+}
+export declare class ObserverHandle {
+    private id;
+    private key;
+    private client;
+    constructor(client: ManagedPncpClient, id: number, key: string);
+    close(): Promise<void>;
+}
+//# sourceMappingURL=managedPncpClient.d.ts.map

package/dist/client/managedPncpClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"managedPncpClient.d.ts","sourceRoot":"","sources":["../../src/client/managedPncpClient.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,wBAAwB,EAAE,qBAAqB,EAAE,MAAM,KAAK,CAAC;AAC5G,OAAO,EAAE,yBAAyB,EAAE,yBAAyB,EAAE,YAAY,EAAE,yBAAyB,EAAqC,mBAAmB,EAAmB,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AACpO,OAAO,UAAU,MAAM,qBAAqB,CAAC;AAE7C,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,KAAK,CAAwD;IACrE,OAAO,CAAC,WAAW,CAAqD;IACxE,OAAO,CAAC,OAAO,CAAwD;IACvE,OAAO,CAAC,MAAM,CAAqE;IACnF,OAAO,CAAC,EAAE,CAAS;IACnB,MAAM,EAAE,kBAAkB,CAAC;gBAEf,IAAI,EAAE,kBAAkB;IA0DvB,WAAW,CAAC,GAAG,EAAE,YAAY,GAAG,OAAO,CAAC,oBAAoB,CAAC;IAiB7D,kBAAkB,CAAC,GAAG,EAAE,YAAY,GAAG,OAAO,CAAC,mBAAmB,CAAC;IAenE,cAAc,CAAC,GAAG,EAAE,wBAAwB,EAAE,EAAE,EAAE,CAAC,GAAG,EAAE,yBAAyB,KAAK,IAAI,GAAG,OAAO,CAAC,cAAc,CAAC;IAcpH,cAAc,CAAC,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM;IAKtC,mBAAmB,CAAC,EAAE,EAAE,qBAAqB,EAAE,EAAE,EAAE,CAAC,GAAG,EAAE,yBAAyB,KAAK,IAAI,GAAG,OAAO,CAAC,MAAM,CAAC;CAY3H;AAED,MAAM,WAAW,oBAAoB;IACnC,KAAK,EAAE,gBAAgB,CAAC;IACxB,IAAI,EAAE,yBAAyB,CAAC;CACjC;AAED,qBAAa,mBAAmB;IAC9B,OAAO,CAAC,KAAK,CAA4C;IACzD,OAAO,CAAC,EAAE,CAAiB;IAC3B,OAAO,CAAC,MAAM,CAAoB;gBAEtB,MAAM,EAAE,iBAAiB,EAAE,KAAK,EAAE,UAAU,CAAC,yBAAyB,CAAC,EAAE,KAAK,EAAE,gBAAgB;IAO/F,IAAI,IAAI,OAAO,CAAC,yBAAyB,GAAG,IAAI,CAAC;IAIjD,YAAY,CAAC,GAAG,EAAE,mBAAmB,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAUjE,UAAU,CAAC,GAAG,EAAE,iBAAiB,GAAG,OAAO,CAAC,gBAAgB,CAAC;CAS3E;AAED,qBAAa,cAAc;IACzB,OAAO,CAAC,EAAE,CAAS;IACnB,OAAO,CAAC,GAAG,CAAS;IACpB,OAAO,CAAC,MAAM,CAAoB;gBAEtB,MAAM,EAAE,iBAAiB,EAAE,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM;IAMjD,KAAK;CAGnB"}

package/dist/client/managedPncpClient.js

@@ -0,0 +1,156 @@
+// Conversation manager to make skill requests which expect a direct response able to wait directly on a
+// response.
+import { ConversationState, PncpMessageKind } from "@otonoma/paranet-client";
+import AsyncQueue from "@ai-zen/async-queue";
+export class ManagedPncpClient {
+    constructor(base) {
+        this.convs = new Map();
+        this.convStreams = new Map();
+        this.observs = new Map();
+        this.skills = new Map();
+        this.id = new Date().getTime() + (Math.floor(Math.random() * 10000));
+        let old = base.msgCb;
+        base.msgCb = (msg) => {
+            if (old)
+                old(msg);
+            if (msg.callback && 'pn/req/id' in msg.callback) {
+                let id = msg.callback['pn/req/id'];
+                if (this.convs.has(id)) {
+                    this.convs.get(id)(msg);
+                    this.convs.delete(id);
+                }
+                else if (this.convStreams.has(id)) {
+                    let queue = this.convStreams.get(id);
+                    if (queue.isDone) {
+                        this.convs.delete(id);
+                    }
+                    else {
+                        queue.push(msg);
+                        if (msg.conversationState == ConversationState.STATE_COMPLETED || msg.conversationState == ConversationState.STATE_ERRORED) {
+                            queue.done();
+                            this.convs.delete(id);
+                        }
+                    }
+                }
+            }
+        };
+        let oldObs = base.obsCb;
+        base.obsCb = (msg, cb) => {
+            if (oldObs)
+                oldObs(msg);
+            console.log("Observer considering callback: ", cb, " on message ", msg);
+            if (cb && 'pn/obs/req/id' in cb) {
+                let id = cb['pn/obs/req/id'];
+                this.observs.get(id)?.(msg);
+            }
+        };
+        let oldSk = base.skillCb;
+        base.skillCb = (msg) => {
+            if (oldSk)
+                oldSk(msg);
+            let key = `${msg.body.subject}/${msg.body.action}`;
+            let inner = this.skills.get(key);
+            if (inner) {
+                for (let cb of inner.values()) {
+                    cb(msg);
+                }
+            }
+        };
+        this.client = base;
+    }
+    // A simple send request which expects _one_ response message.
+    // To make a call which can expect multiple responses, use `createConversation`.
+    async sendRequest(req) {
+        let id = this.id++;
+        if (!req.callback) {
+            req.callback = {};
+        }
+        req.callback['pn/req/id'] = id;
+        let promise = new Promise((res) => {
+            this.convs.set(id, (pncp) => res(pncp));
+        });
+        let reply = await this.client.pncpRequest(req);
+        return new Promise(async (res) => {
+            let pncp = await promise;
+            res({ reply, pncp });
+        });
+    }
+    async createConversation(req) {
+        let id = this.id++;
+        if (!req.callback) {
+            req.callback = {};
+        }
+        req.callback['pn/req/id'] = id;
+        let queue = new AsyncQueue();
+        this.convStreams.set(id, queue);
+        let reply = await this.client.pncpRequest(req);
+        return new ConversationHandler(this, queue, reply);
+    }
+    async createObserver(obs, cb) {
+        let id = this.id++;
+        if (!obs.callback) {
+            obs.callback = {};
+        }
+        obs.callback['pn/obs/req/id'] = id;
+        this.observs.set(id, cb);
+        // NOTE: This can be clever enough to avoid duplicating these callbacks, but the paracord side can manage
+        // that too, so this should be OK.
+        // TODO: Does this return something useful?
+        let { args: { key } } = await this.client.registerObserverCallback(obs);
+        return new ObserverHandle(this, id, key);
+    }
+    async deleteObserver(id, key) {
+        this.observs.delete(id);
+        await this.client.deleteObserver(key);
+    }
+    async createSkillCallback(sk, cb) {
+        let key = `${sk.subject}/${sk.action}`;
+        if (!this.skills.has(key)) {
+            await this.client.registerSkillCallback(sk);
+            this.skills.set(key, new Map());
+        }
+        let inner = this.skills.get(key);
+        let id = this.id++;
+        inner.set(id, cb);
+        return id;
+    }
+}
+export class ConversationHandler {
+    constructor(client, queue, reply) {
+        this.queue = queue[Symbol.asyncIterator]();
+        // TODO: Throw an error here if this is empty.
+        this.id = reply.conversationId;
+        this.client = client;
+    }
+    async next() {
+        return (await this.queue.next()).value;
+    }
+    async sendQuestion(req) {
+        return await this.client.client.pncpMessage({
+            id: this.id,
+            body: {
+                type: PncpMessageKind.PNCP_QUESTION,
+                value: req,
+            },
+        });
+    }
+    async sendAnswer(req) {
+        return await this.client.client.pncpMessage({
+            id: this.id,
+            body: {
+                type: PncpMessageKind.PNCP_ANSWER,
+                value: req,
+            }
+        });
+    }
+}
+export class ObserverHandle {
+    constructor(client, id, key) {
+        this.client = client;
+        this.id = id;
+        this.key = key;
+    }
+    async close() {
+        await this.client.deleteObserver(this.id, this.key);
+    }
+}

package/dist/client/paracordClient.d.ts

@@ -0,0 +1,28 @@
+import { DocumentArgs, LoginCredentials, ObservationCallbackObject, PncpMessageCallbackObject, PncpMessageObject, PncpRequestCallbackObject, SkillRequest } from "@otonoma/paranet-client";
+import { Channel } from "../channel";
+import { PncpMessageResponse, MethodCall, RegisterSkillCallback, PncpCallResponse, RegisterObserverCallback, GraphqlCallArgs, GraphqlCallResponse, UploadDocumentArgs, UploadDocumentResponse, FetchDocumentResponse, RegisterObserverResponse } from "../interface/methods";
+import { AbstractPncpClient, PncpClientInit } from "../";
+export declare class ParacordClient extends AbstractPncpClient {
+    channel: Channel;
+    skillCb?: (msg: PncpRequestCallbackObject) => void;
+    msgCb?: (msg: PncpMessageCallbackObject) => void;
+    obsCb?: (msg: ObservationCallbackObject, callback?: any) => void;
+    constructor(init?: PncpClientInit);
+    issueCall(call: MethodCall): Promise<any>;
+    login(_creds: LoginCredentials): Promise<void>;
+    pncpRequest(req: SkillRequest): Promise<PncpCallResponse>;
+    pncpResponse(req: PncpMessageResponse): Promise<PncpCallResponse>;
+    pncpMessage(req: PncpMessageObject): Promise<PncpCallResponse>;
+    registerSkillCallback(req: RegisterSkillCallback): Promise<any>;
+    registerObserverCallback(req: RegisterObserverCallback): Promise<RegisterObserverResponse>;
+    deleteObserver(key: string): Promise<void>;
+    uploadDocument(args: UploadDocumentArgs): Promise<UploadDocumentResponse>;
+    fetchDocument(args: DocumentArgs): Promise<FetchDocumentResponse>;
+    graphqlCall(args: GraphqlCallArgs): Promise<GraphqlCallResponse>;
+}
+export interface ParacordClientInit {
+    skill?: (msg: PncpRequestCallbackObject) => void;
+    msg?: (msg: PncpMessageCallbackObject) => void;
+    obs?: (msg: ObservationCallbackObject, callback?: any) => void;
+}
+//# sourceMappingURL=paracordClient.d.ts.map

package/dist/client/paracordClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"paracordClient.d.ts","sourceRoot":"","sources":["../../src/client/paracordClient.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,YAAY,EACZ,gBAAgB,EAChB,yBAAyB,EACzB,yBAAyB,EACzB,iBAAiB,EACjB,yBAAyB,EACzB,YAAY,EACb,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAMrC,OAAO,EACL,mBAAmB,EACnB,UAAU,EACV,qBAAqB,EACrB,gBAAgB,EAChB,wBAAwB,EACxB,eAAe,EACf,mBAAmB,EACnB,kBAAkB,EAClB,sBAAsB,EACtB,qBAAqB,EACrB,wBAAwB,EACzB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,kBAAkB,EAAE,cAAc,EAAE,MAAM,KAAK,CAAC;AAEzD,qBAAa,cAAe,SAAQ,kBAAkB;IACpD,OAAO,EAAE,OAAO,CAAC;IACjB,OAAO,CAAC,EAAE,CAAC,GAAG,EAAE,yBAAyB,KAAK,IAAI,CAAC;IACnD,KAAK,CAAC,EAAE,CAAC,GAAG,EAAE,yBAAyB,KAAK,IAAI,CAAC;IACjD,KAAK,CAAC,EAAE,CAAC,GAAG,EAAE,yBAAyB,EAAE,QAAQ,CAAC,EAAE,GAAG,KAAK,IAAI,CAAC;gBACrD,IAAI,CAAC,EAAE,cAAc;IAmC3B,SAAS,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,GAAG,CAAC;IAgBlC,KAAK,CAAC,MAAM,EAAE,gBAAgB;IAE9B,WAAW,CAAC,GAAG,EAAE,YAAY,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAIzD,YAAY,CACvB,GAAG,EAAE,mBAAmB,GACvB,OAAO,CAAC,gBAAgB,CAAC;IAIf,WAAW,CACtB,GAAG,EAAE,iBAAiB,GACrB,OAAO,CAAC,gBAAgB,CAAC;IAKf,qBAAqB,CAAC,GAAG,EAAE,qBAAqB;IAIhD,wBAAwB,CAAC,GAAG,EAAE,wBAAwB,GAAG,OAAO,CAAC,wBAAwB,CAAC;IAO1F,cAAc,CAAC,GAAG,EAAE,MAAM;IAI1B,cAAc,CAAC,IAAI,EAAE,kBAAkB,GAAG,OAAO,CAAC,sBAAsB,CAAC;IAOzE,aAAa,CAAC,IAAI,EAAE,YAAY,GAAG,OAAO,CAAC,qBAAqB,CAAC;IAOjE,WAAW,CAAC,IAAI,EAAE,eAAe,GAAG,OAAO,CAAC,mBAAmB,CAAC;CAM9E;AAED,MAAM,WAAW,kBAAkB;IACjC,KAAK,CAAC,EAAE,CAAC,GAAG,EAAE,yBAAyB,KAAK,IAAI,CAAC;IACjD,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,yBAAyB,KAAK,IAAI,CAAC;IAC/C,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,yBAAyB,EAAE,QAAQ,CAAC,EAAE,GAAG,KAAK,IAAI,CAAC;CAChE"}

package/dist/client/paracordClient.js

@@ -0,0 +1,97 @@
+// Client for panels to connect to paracord and send requests.
+import { Channel } from "../channel";
+import { PARACORD_PANEL_REVISION, } from "../interface";
+import { AbstractPncpClient } from "../";
+export class ParacordClient extends AbstractPncpClient {
+    constructor(init) {
+        super(init);
+        // Provided by Paracord.
+        const panelId = window.name;
+        // TODO (JAB): All of the message handling requests should be abstracted in a way that can be generalized
+        // to run in non-panel specific environments. This will make it easier to develop new panels as totally
+        // independent apps instead of requiring the panel embedding. This should both enable quicker/easier
+        // development but also greater portability of the panel code.
+        const message = {
+            apiRevision: PARACORD_PANEL_REVISION,
+            panelId,
+            type: "panelConnect",
+        };
+        const msgChan = new MessageChannel();
+        // TODO: Implement proper callback here.
+        const channel = new Channel(panelId, msgChan.port1, (msg) => {
+            console.log("Got callback:", msg);
+            switch (msg.body.type) {
+                case "pncpSkillCb":
+                    this.skillCb?.(msg.body.body);
+                    break;
+                case "pncpMessageCb":
+                    this.msgCb?.(msg.body.body);
+                    break;
+                case "pncpObservationCb":
+                    this.obsCb?.(msg.body.body, msg.body.callback);
+                    break;
+            }
+        });
+        this.channel = channel;
+        // Call the background.
+        console.log("Posting channel");
+        top?.postMessage(message, "*", [msgChan.port2]);
+    }
+    async issueCall(call) {
+        const body = {
+            type: "call",
+            body: call,
+        };
+        const response = await this.channel.asyncSend(body);
+        if (response.type == "callReturn") {
+            return response.body;
+        }
+        else if (response.type == "paracordError") {
+            throw Error(response.error);
+        }
+        else {
+            throw Error("Incorrect response type.");
+        }
+    }
+    async login(_creds) { }
+    async pncpRequest(req) {
+        return await this.issueCall({ method: "pncpRequest", args: req });
+    }
+    async pncpResponse(req) {
+        return await this.issueCall({ method: "pncpResponse", args: req });
+    }
+    async pncpMessage(req) {
+        return await this.issueCall({ method: "pncpMessage", args: req });
+    }
+    // Registers the callback with paracord.
+    async registerSkillCallback(req) {
+        return await this.issueCall({ method: "registerSkillCallback", args: req });
+    }
+    async registerObserverCallback(req) {
+        return await this.issueCall({
+            method: "registerObserverCallback",
+            args: req,
+        });
+    }
+    async deleteObserver(key) {
+        await this.issueCall({ method: "unregisterObserverCallback", args: { key } });
+    }
+    async uploadDocument(args) {
+        return await this.issueCall({
+            method: "uploadDocumentCall",
+            args,
+        });
+    }
+    async fetchDocument(args) {
+        return await this.issueCall({
+            method: "fetchDocumentCall",
+            args,
+        });
+    }
+    async graphqlCall(args) {
+        return await this.issueCall({
+            method: "graphqlCall",
+            args,
+        });
+    }
+}

package/dist/client/pncpClient.d.ts

@@ -0,0 +1,34 @@
+import { DocumentArgs, LoginCredentials, PncpMessageObject, SkillRequest, TokenResponse } from "@otonoma/paranet-client";
+import { AbstractPncpClient, PncpClientInit } from ".";
+import { FetchDocumentResponse, GraphqlCallArgs, GraphqlCallResponse, PncpCallResponse, PncpMessageResponse, RegisterObserverCallback, RegisterObserverResponse, RegisterSkillCallback, UploadDocumentArgs, UploadDocumentResponse } from "../interface";
+export type ConnectionState = "connected" | "disconnected" | "pending" | "unauthenticated" | "failed";
+export declare class PncpRpcClient extends AbstractPncpClient {
+    private client;
+    private svcClient;
+    private listener;
+    private observerState;
+    actorId: string;
+    actorVersion: string;
+    connectionState: ConnectionState;
+    constructor(init: PncpRpcClientInit);
+    login(creds: LoginCredentials): Promise<void>;
+    pncpRequest(req: SkillRequest): Promise<PncpCallResponse>;
+    pncpResponse(req: PncpMessageResponse): Promise<PncpCallResponse>;
+    pncpMessage(data: PncpMessageObject): Promise<PncpCallResponse>;
+    registerSkillCallback(_req: RegisterSkillCallback): Promise<void>;
+    registerObserverCallback(req: RegisterObserverCallback): Promise<RegisterObserverResponse>;
+    private createOrGetObserverStream;
+    deleteObserver(key: string): Promise<void>;
+    uploadDocument(args: UploadDocumentArgs): Promise<UploadDocumentResponse>;
+    fetchDocument(args: DocumentArgs): Promise<FetchDocumentResponse>;
+    graphqlCall(args: GraphqlCallArgs): Promise<GraphqlCallResponse>;
+}
+export interface PncpRpcClientInit {
+    init?: PncpClientInit;
+    actorId: string;
+    actorVersion: string;
+    broker: string;
+    service: string;
+    tokens?: TokenResponse;
+}
+//# sourceMappingURL=pncpClient.d.ts.map

package/dist/client/pncpClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pncpClient.d.ts","sourceRoot":"","sources":["../../src/client/pncpClient.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,YAAY,EAAE,gBAAgB,EAAyQ,iBAAiB,EAAgF,YAAY,EAAa,aAAa,EAAE,MAAM,yBAAyB,CAAC;AACzd,OAAO,EAAE,kBAAkB,EAAE,cAAc,EAAE,MAAM,GAAG,CAAC;AACvD,OAAO,EAAE,qBAAqB,EAAE,eAAe,EAAE,mBAAmB,EAAE,gBAAgB,EAAE,mBAAmB,EAAE,wBAAwB,EAAE,wBAAwB,EAAE,qBAAqB,EAAE,kBAAkB,EAAE,sBAAsB,EAAE,MAAM,cAAc,CAAC;AAEzP,MAAM,MAAM,eAAe,GACvB,WAAW,GACX,cAAc,GACd,SAAS,GACT,iBAAiB,GACjB,QAAQ,CAAC;AAOb,qBAAa,aAAc,SAAQ,kBAAkB;IAEnD,OAAO,CAAC,MAAM,CAAa;IAC3B,OAAO,CAAC,SAAS,CAAuB;IACxC,OAAO,CAAC,QAAQ,CAAe;IAC/B,OAAO,CAAC,aAAa,CAA6B;IAElD,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY,EAAE,MAAM,CAAC;IAGrB,eAAe,EAAE,eAAe,CAAC;gBAErB,IAAI,EAAE,iBAAiB;IAsEtB,KAAK,CAAC,KAAK,EAAE,gBAAgB;IAK7B,WAAW,CAAC,GAAG,EAAE,YAAY,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAezD,YAAY,CACvB,GAAG,EAAE,mBAAmB,GACvB,OAAO,CAAC,gBAAgB,CAAC;IAoBf,WAAW,CAAC,IAAI,EAAE,iBAAiB,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAa/D,qBAAqB,CAAC,IAAI,EAAE,qBAAqB;IAKjD,wBAAwB,CAAC,GAAG,EAAE,wBAAwB,GAAG,OAAO,CAAC,wBAAwB,CAAC;IAsCvG,OAAO,CAAC,yBAAyB;IA6CpB,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAS1C,cAAc,CAAC,IAAI,EAAE,kBAAkB,GAAG,OAAO,CAAC,sBAAsB,CAAC;IAQzE,aAAa,CAAC,IAAI,EAAE,YAAY,GAAG,OAAO,CAAC,qBAAqB,CAAC;IAgBjE,WAAW,CAAC,IAAI,EAAE,eAAe,GAAG,OAAO,CAAC,mBAAmB,CAAC;CAQ9E;AAQD,MAAM,WAAW,iBAAiB;IAChC,IAAI,CAAC,EAAE,cAAc,CAAC;IACtB,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY,EAAE,MAAM,CAAC;IACrB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,aAAa,CAAC;CACxB"}