@web-applets/sdk 0.1.5 → 0.2.0-alpha.9

package/dist/core/context.d.ts

@@ -1,32 +0,0 @@
-import { ActionParams, AppletDataEvent, AppletLoadEvent, AppletReadyEvent, JSONSchema, AppletManifest, AppletAction, AppletMessageRelay } from './shared';
-export type ActionHandler<T extends ActionParams> = (params: T) => void | Promise<void>;
-export type ActionHandlerDict = {
-    [key: string]: ActionHandler<any>;
-};
-export declare class AppletContext extends EventTarget {
-    #private;
-    messageRelay: AppletMessageRelay;
-    actionHandlers: ActionHandlerDict;
-    manifest: AppletManifest;
-    constructor();
-    connect(): void;
-    initialize(): Promise<void>;
-    createResizeObserver(): void;
-    attachListeners(): void;
-    setActionHandler<T = ActionParams>(actionId: string, handler: ActionHandler<T>): void;
-    defineAction<T = ActionParams>(actionId: string, definition: ActionDefinition<T>): void;
-    set actions(actions: AppletAction[]);
-    get actions(): AppletAction[];
-    set data(data: any);
-    get data(): any;
-    setData(data: any): Promise<void>;
-    onload(event: AppletLoadEvent): Promise<void> | void;
-    onready(event: AppletReadyEvent): void;
-    ondata(event: AppletDataEvent): void;
-}
-interface ActionDefinition<T> extends Omit<AppletAction, 'id'> {
-    parameters?: JSONSchema;
-    handler?: ActionHandler<T>;
-}
-export declare function getContext(): AppletContext;
-export {};

package/dist/core/context.js

@@ -1,138 +0,0 @@
-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 __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 _AppletContext_actions, _AppletContext_data;
-import { AppletMessage, AppletDataEvent, AppletLoadEvent, AppletReadyEvent, AppletActionsMessage, AppletReadyMessage, AppletMessageRelay, } from './shared';
-export class AppletContext extends EventTarget {
-    constructor() {
-        super();
-        this.actionHandlers = {};
-        _AppletContext_actions.set(this, {});
-        _AppletContext_data.set(this, void 0);
-        this.connect();
-    }
-    connect() {
-        this.messageRelay = new AppletMessageRelay(window.parent);
-        // When document loads/if it's loaded, call the initialize function
-        if (document.readyState === 'complete' ||
-            document.readyState === 'interactive') {
-            // Document has loaded already.
-            // Timeout added so if the caller defines the onload function, it will exist by now
-            setTimeout(this.initialize.bind(this), 1);
-        }
-        else {
-            // Document not yet loaded, we'll add an event listener to call when it does
-            window.addEventListener('DOMContentLoaded', this.initialize.bind(this));
-        }
-        this.attachListeners();
-    }
-    async initialize() {
-        const manifestLinkElem = document.querySelector('link[rel="manifest"]');
-        if (!manifestLinkElem)
-            return;
-        try {
-            const manifestRequest = await fetch(manifestLinkElem.href);
-            const manifest = await manifestRequest.json();
-            this.manifest = manifest;
-            this.actions = manifest.actions ?? [];
-        }
-        catch (e) {
-            return;
-        }
-        // Call the onload function
-        const loadEvent = new AppletLoadEvent();
-        this.dispatchEvent(loadEvent);
-        if (typeof this.onload === 'function')
-            await this.onload(loadEvent);
-        // Tell the host we're ready
-        this.messageRelay.send(new AppletReadyMessage());
-        // Emit a local ready event
-        const readyEvent = new AppletReadyEvent();
-        this.dispatchEvent(readyEvent);
-        if (typeof this.onready === 'function')
-            this.onready(readyEvent);
-        this.createResizeObserver();
-    }
-    createResizeObserver() {
-        const resizeObserver = new ResizeObserver((entries) => {
-            for (let entry of entries) {
-                const message = new AppletMessage('resize', {
-                    dimensions: {
-                        width: entry.contentRect.width,
-                        height: entry.contentRect.height,
-                    },
-                });
-                this.messageRelay.send(message);
-            }
-        });
-        resizeObserver.observe(document.querySelector('html'));
-    }
-    attachListeners() {
-        this.messageRelay.on('init', (message) => {
-            this.manifest = message.manifest;
-            this.actions = this.manifest?.actions || [];
-        });
-        this.messageRelay.on('data', (message) => {
-            this.setData(message.data);
-        });
-        this.messageRelay.on('action', async (message) => {
-            if (Object.keys(this.actionHandlers).includes(message.actionId)) {
-                await this.actionHandlers[message.actionId](message.params);
-            }
-        });
-    }
-    setActionHandler(actionId, handler) {
-        this.actionHandlers[actionId] = handler;
-    }
-    defineAction(actionId, definition) {
-        const { handler, ...properties } = definition;
-        this.actions = [
-            ...this.actions,
-            {
-                id: actionId,
-                ...properties,
-            },
-        ];
-        this.setActionHandler(actionId, handler);
-    }
-    set actions(actions) {
-        if (!actions)
-            return;
-        for (let action of actions) {
-            __classPrivateFieldGet(this, _AppletContext_actions, "f")[action.id] = action;
-        }
-        this.messageRelay.send(new AppletActionsMessage({ actions: this.actions }));
-    }
-    get actions() {
-        return Object.values(__classPrivateFieldGet(this, _AppletContext_actions, "f"));
-    }
-    set data(data) {
-        this.setData(data);
-    }
-    get data() {
-        return __classPrivateFieldGet(this, _AppletContext_data, "f");
-    }
-    async setData(data) {
-        const dataMessage = new AppletMessage('data', { data });
-        await this.messageRelay.send(dataMessage);
-        __classPrivateFieldSet(this, _AppletContext_data, data, "f");
-        const dataEvent = new AppletDataEvent({ data });
-        this.dispatchEvent(dataEvent);
-        this.ondata(dataEvent);
-    }
-    onload(event) { }
-    onready(event) { }
-    ondata(event) { }
-}
-_AppletContext_actions = new WeakMap(), _AppletContext_data = new WeakMap();
-export function getContext() {
-    return new AppletContext();
-}

package/dist/core/shared.d.ts

@@ -1,124 +0,0 @@
-export interface AppletManifest {
-    name?: string;
-    short_name?: string;
-    icons: ManifestIcon[];
-    description?: string;
-    display?: string;
-    start_url?: string;
-    unsafe?: boolean;
-    actions?: AppletAction[];
-}
-export interface ManifestIcon {
-    src: string;
-    purpose?: string;
-    sizes?: string;
-    type?: string;
-}
-export interface AppletAction {
-    id: string;
-    name?: string;
-    description?: string;
-    parameters?: JSONSchema;
-}
-export interface JSONSchema {
-    type: 'object' | 'string' | 'number' | 'integer' | 'array' | 'boolean' | 'null';
-    description?: string;
-    properties?: {
-        [key: string]: JSONSchema;
-    };
-    required?: string[];
-    additionalProperties?: boolean;
-}
-export type ActionParams = Record<string, any>;
-export declare function loadManifest(pageUrl: string): Promise<AppletManifest>;
-interface SendMessageOptions {
-    resolves: boolean;
-}
-export declare class AppletMessageRelay {
-    target: Window;
-    constructor(target: Window);
-    send(message: AppletMessage, options?: SendMessageOptions): Promise<AppletMessage>;
-    on(messageType: AppletMessageType, callback: AppletMessageCallback): Promise<void>;
-}
-export declare class AppletMessage {
-    type: AppletMessageType;
-    id: string;
-    timeStamp: number;
-    [key: string]: any;
-    constructor(type: AppletMessageType, values?: {
-        [key: string]: any;
-    });
-    toJson(): {
-        [k: string]: any;
-    };
-}
-export declare class AppletResolveMessage extends AppletMessage {
-    messageId: string;
-    constructor({ id }: {
-        id: string;
-    });
-}
-export declare class AppletActionsMessage extends AppletMessage {
-    actions: AppletAction[];
-    constructor({ actions }: {
-        actions: AppletAction[];
-    });
-}
-export declare class AppletDataMessage<T = any> extends AppletMessage {
-    data: T;
-    constructor({ data }: {
-        data: T;
-    });
-}
-export declare class AppletReadyMessage extends AppletMessage {
-    constructor();
-}
-export declare class AppletResizeMessage extends AppletMessage {
-    dimensions: {
-        height: number;
-        width: number;
-    };
-    constructor({ dimensions, }: {
-        dimensions: AppletResizeMessage['dimensions'];
-    });
-}
-interface AppletActionMessageOptions {
-    actionId: string;
-    params: any;
-}
-export declare class AppletActionMessage extends AppletMessage {
-    actionId: string;
-    params: any;
-    constructor({ actionId, params }: AppletActionMessageOptions);
-}
-export declare class AppletInitMessage extends AppletMessage {
-    constructor();
-}
-export type AppletMessageType = 'action' | 'actions' | 'data' | 'init' | 'ready' | 'style' | 'resolve' | 'resize';
-export type AppletMessageCallback = (message: AppletMessage) => Promise<void> | void;
-export declare class AppletDataEvent extends Event {
-    data: any;
-    constructor({ data }: {
-        data: any;
-    });
-}
-export declare class AppletReadyEvent extends Event {
-    constructor();
-}
-export declare class AppletLoadEvent extends Event {
-    constructor();
-}
-export declare class AppletActionsEvent extends Event {
-    actions: AppletAction[];
-    constructor({ actions }: {
-        actions: AppletAction[];
-    });
-}
-export interface AppletResizeEventOpts {
-    dimensions: AppletResizeMessage['dimensions'];
-}
-export declare class AppletResizeEvent extends Event {
-    dimensions: AppletResizeMessage['dimensions'];
-    constructor({ dimensions }: AppletResizeEventOpts);
-}
-export {};

package/dist/core/shared.js

@@ -1,177 +0,0 @@
-/* Manifest & action definitions */
-import { parseUrl } from '../utils';
-export async function loadManifest(pageUrl) {
-    pageUrl = parseUrl(pageUrl);
-    let manifest;
-    try {
-        const pageRequest = await fetch(pageUrl);
-        const html = await pageRequest.text();
-        const parser = new DOMParser();
-        const doc = parser.parseFromString(html, 'text/html');
-        const linkElem = doc.querySelector('link[rel="manifest"]');
-        const href = linkElem.getAttribute('href');
-        const manifestUrl = parseUrl(href, pageUrl);
-        const manifestRequest = await fetch(manifestUrl);
-        manifest = await manifestRequest.json();
-        manifest.icons = manifest.icons.map((icon) => {
-            icon.src = parseUrl(icon.src, pageUrl);
-            return icon;
-        });
-    }
-    catch (e) {
-        return;
-    }
-    return manifest;
-}
-export class AppletMessageRelay {
-    constructor(target) {
-        this.target = target;
-    }
-    async send(message, options) {
-        this.target.postMessage(message.toJson(), '*');
-        if (options && options.resolves === false)
-            return;
-        // Wait for a resolve message to be sent back before completing await
-        return new Promise((resolve) => {
-            const listener = (messageEvent) => {
-                const responseMessage = new AppletMessage(messageEvent.data.type, messageEvent.data);
-                if (responseMessage.type === 'resolve' &&
-                    responseMessage.id === message.id) {
-                    window.removeEventListener('message', listener);
-                    resolve(responseMessage);
-                }
-            };
-            window.addEventListener('message', listener);
-        });
-    }
-    async on(messageType, callback) {
-        const listener = async (messageEvent) => {
-            if (messageEvent.source === window.self)
-                return;
-            if (messageEvent.data.type !== messageType)
-                return;
-            if (messageEvent.source !== this.target)
-                return;
-            const message = new AppletMessage(messageEvent.data.type, messageEvent.data);
-            // Wait for the callback to complete, then send a 'resolve' event
-            // with the message ID.
-            await callback(message);
-            const resolveMessage = new AppletResolveMessage({ id: message.id });
-            this.send(resolveMessage, { resolves: false });
-        };
-        window.addEventListener('message', listener);
-        // TODO: Return something that I can then call .off or .removeListener, implement the
-        // rest of that event class
-    }
-}
-/* Messages */
-export class AppletMessage {
-    constructor(type, values) {
-        this.timeStamp = Date.now();
-        this.type = type;
-        this.id = crypto.randomUUID();
-        if (values)
-            Object.assign(this, values);
-    }
-    toJson() {
-        return Object.fromEntries(Object.entries(this).filter(([_, value]) => {
-            try {
-                JSON.stringify(value);
-                return true;
-            }
-            catch {
-                return false;
-            }
-        }));
-    }
-}
-export class AppletResolveMessage extends AppletMessage {
-    constructor({ id }) {
-        super('resolve');
-        this.id = id;
-    }
-}
-export class AppletActionsMessage extends AppletMessage {
-    constructor({ actions }) {
-        super('actions');
-        this.actions = actions;
-    }
-}
-export class AppletDataMessage extends AppletMessage {
-    constructor({ data }) {
-        super('data');
-        this.data = data;
-    }
-}
-export class AppletReadyMessage extends AppletMessage {
-    constructor() {
-        super('ready');
-    }
-}
-export class AppletResizeMessage extends AppletMessage {
-    constructor({ dimensions, }) {
-        super('resize');
-        this.dimensions = dimensions;
-    }
-}
-export class AppletActionMessage extends AppletMessage {
-    constructor({ actionId, params }) {
-        super('action');
-        this.actionId = actionId;
-        this.params = params;
-    }
-}
-export class AppletInitMessage extends AppletMessage {
-    constructor() {
-        super('init');
-    }
-}
-/* Events */
-export class AppletDataEvent extends Event {
-    constructor({ data }) {
-        super('data', {
-            bubbles: false,
-            cancelable: false,
-            composed: false,
-        });
-        this.data = data;
-    }
-}
-export class AppletReadyEvent extends Event {
-    constructor() {
-        super('ready', {
-            bubbles: false,
-            cancelable: false,
-            composed: false,
-        });
-    }
-}
-export class AppletLoadEvent extends Event {
-    constructor() {
-        super('load', {
-            bubbles: false,
-            cancelable: false,
-            composed: false,
-        });
-    }
-}
-export class AppletActionsEvent extends Event {
-    constructor({ actions }) {
-        super('actions', {
-            bubbles: false,
-            cancelable: false,
-            composed: false,
-        });
-        this.actions = actions;
-    }
-}
-export class AppletResizeEvent extends Event {
-    constructor({ dimensions }) {
-        super('resize', {
-            bubbles: false,
-            cancelable: false,
-            composed: false,
-        });
-        this.dimensions = dimensions;
-    }
-}

package/dist/types.d.ts

@@ -1,9 +0,0 @@
-export interface JSONSchema {
-    type: 'object' | 'string' | 'number' | 'integer' | 'array' | 'boolean' | 'null';
-    description?: string;
-    properties?: {
-        [key: string]: JSONSchema;
-    };
-    required?: string[];
-    additionalProperties?: boolean;
-}