@omujs/omu 0.9.31 → 0.9.33

package/src/api/http/websocket.ts

@@ -0,0 +1,283 @@
+import { textDecoder } from '../../const';
+import { DataChunk, RequestHandle } from './http';
+
+export type WSData = string | ArrayBufferLike | Blob | ArrayBufferView;
+
+export const WSMsgType = {
+    CONTINUATION: 0x0,
+    TEXT: 0x1,
+    BINARY: 0x2,
+    PING: 0x9,
+    PONG: 0xA,
+    CLOSE: 0x8,
+} as const;
+
+export const WSCloseCode = {
+    OK: 1000,
+    GOING_AWAY: 1001,
+    PROTOCOL_ERROR: 1002,
+    UNSUPPORTED_DATA: 1003,
+    ABNORMAL_CLOSURE: 1006,
+    INVALID_TEXT: 1007,
+    POLICY_VIOLATION: 1008,
+    MESSAGE_TOO_BIG: 1009,
+    MANDATORY_EXTENSION: 1010,
+    INTERNAL_ERROR: 1011,
+    SERVICE_RESTART: 1012,
+    TRY_AGAIN_LATER: 1013,
+    BAD_GATEWAY: 1014,
+} as const;
+
+export type WebSocketOpen = RequestHandle & {
+    url: string;
+    protocol?: string | null;
+};
+export type WebSocketClose = RequestHandle & {
+    code?: number;
+    reason?: string | null;
+};
+export type WebSocketError = RequestHandle & {
+    type: 'ConnectionRefused';
+    reason?: string | null;
+};
+
+export type EventListenerMap<T> = {
+    [K in keyof T]: ((event: T[K]) => unknown)[]
+};
+
+export type WSMsg = {
+    type: 'open';
+    data: WebSocketOpen;
+} | {
+    type: 'error';
+    data: WebSocketError;
+} | {
+    type: 'text';
+    data: string;
+} | {
+    type: 'binary';
+    data: Uint8Array;
+} | {
+    type: 'close';
+    data: WebSocketClose;
+};
+
+export type WebSocketHandle = {
+    ws: OmuWS;
+    open: (response: WebSocketOpen) => void;
+    dispatch: (data: DataChunk<WSDataMeta>) => void;
+    close: (response: WebSocketClose) => void;
+    error: (response: WebSocketError) => void;
+};
+
+export type WSDataMeta = {
+    id: string;
+    type:
+        | typeof WSMsgType.TEXT
+        | typeof WSMsgType.BINARY
+        | typeof WSMsgType.PING
+        | typeof WSMsgType.PONG;
+};
+
+export type WSHandleState = {
+    type: 'created' | 'receiving';
+    handle: WebSocketHandle;
+};
+
+type WSOptions = {
+    addQueue: (data: WSData) => void;
+    dispose(options: {
+        code?: number;
+        reason?: string;
+    }): void;
+};
+
+export class OmuWS {
+    constructor(
+        protected readonly addQueue: (data: WSData) => void,
+        protected readonly dispose: (options: { code?: number; reason?: string }) => void,
+        protected readonly receiveQueue: WSMsg[] = [],
+        private receiveResolve: (() => void) | undefined = undefined,
+        private status: 'connecting' | 'open' | 'closed' = 'connecting',
+    ) { }
+
+    public toWebSocket(): OmuWebSocket {
+        return new OmuWebSocket(this);
+    }
+
+    public static create(options: WSOptions): WebSocketHandle {
+        const ws = new OmuWS(options.addQueue, options.dispose);
+        return {
+            ws,
+            open: (response) => {
+                ws.receiveQueue.push({
+                    type: 'open',
+                    data: response,
+                });
+                ws.receiveResolve?.();
+            },
+            dispatch: (data: DataChunk<WSDataMeta>): void => {
+                if (data.meta.type === WSMsgType.BINARY) {
+                    ws.receiveQueue.push({
+                        type: 'binary',
+                        data: data.body,
+                    });
+                } else {
+                    ws.receiveQueue.push({
+                        type: 'text',
+                        data: textDecoder.decode(data.body),
+                    });
+                }
+                ws.receiveResolve?.();
+            },
+            close: (response) => {
+                ws.receiveQueue.push({
+                    type: 'close',
+                    data: response,
+                });
+                ws.receiveResolve?.();
+            },
+            error: (response) => {
+                ws.receiveQueue.push({
+                    type: 'error',
+                    data: response,
+                });
+                ws.receiveResolve?.();
+            },
+        };
+    }
+
+    public send(data: WSData): void {
+        this.addQueue(data);
+    }
+
+    public close(code?: number, reason?: string): void {
+        this.dispose({ code, reason });
+    }
+
+    public async receive(): Promise<WSMsg> {
+        if (this.receiveResolve) {
+            throw new Error('Already receiving from another async call');
+        }
+        while (this.status !== 'closed') {
+            const data = this.receiveQueue.shift();
+            if (!data) {
+                await new Promise<void>((resolve) => this.receiveResolve = resolve);
+                continue;
+            }
+            if (data.type === 'close') {
+                this.status = 'closed';
+            }
+            if (data.type === 'open') {
+                this.status = 'open';
+            }
+            this.receiveResolve = undefined;
+            return data;
+        }
+        throw new Error('Receiving on already closed socket');
+    }
+
+    protocol: string = '';
+    url: string = '';
+}
+
+export class OmuWebSocket implements WebSocket {
+    public CONNECTING = 0 as const;
+    public OPEN = 1 as const;
+    public CLOSING = 2 as const;
+    public CLOSED = 3 as const;
+
+    binaryType: BinaryType = 'blob';
+    bufferedAmount: number = 0;
+    extensions: string = '';
+    onclose: ((this: WebSocket, ev: CloseEvent) => unknown) | null = null;
+    onerror: ((this: WebSocket, ev: Event) => unknown) | null = null;
+    onmessage: ((this: WebSocket, ev: MessageEvent) => unknown) | null = null;
+    onopen: ((this: WebSocket, ev: Event) => unknown) | null = null;
+    protocol: string = '';
+    readyState: 0 | 2 | 1 | 3 = 0;
+    url: string = '';
+
+    constructor(
+        protected readonly ws: OmuWS,
+        private readonly eventListeners: EventListenerMap<WebSocketEventMap> = {
+            close: [],
+            error: [],
+            message: [],
+            open: [],
+        },
+    ) {
+        this.receiveLoop();
+    }
+
+    private async receiveLoop() {
+        while (this.readyState === WebSocket.CLOSED) {
+            const { data, type } = await this.ws.receive();
+            switch (type) {
+                case 'close':
+                    this.dispatchEvent(new CloseEvent('close', {
+                        code: data.code,
+                        reason: data.reason ?? undefined,
+                    }));
+                    break;
+                case 'open':
+                    this.url = data.url;
+                    this.protocol = data.protocol ?? '';
+                    this.dispatchEvent(new Event('open', {}));
+                    break;
+                case 'error':
+                    this.dispatchEvent(new ErrorEvent('error', {
+                        error: data.type,
+                        message: data.reason ?? undefined,
+                    }));
+                    break;
+                case 'text':
+                case 'binary':
+                    this.dispatchEvent(new MessageEvent('message', {
+                        data,
+                    }));
+                    break;
+            }
+        }
+    }
+
+    dispatchEvent(event: Event): boolean {
+        const listeners = this.eventListeners[event.type];
+        for (const listener of listeners) {
+            listener(event);
+        }
+        if (event.type === 'open') {
+            this.onopen?.(event as MessageEvent);
+        }
+        if (event.type === 'error') {
+            this.onerror?.(event);
+        }
+        if (event.type === 'message') {
+            this.onmessage?.(event as MessageEvent);
+        }
+        if (event.type === 'close') {
+            this.onclose?.(event as CloseEvent);
+        }
+        return true;
+    }
+
+    send(data: string | ArrayBufferLike | Blob | ArrayBufferView): void {
+        this.ws.send(data);
+    }
+
+    close(code?: number, reason?: string): void {
+        this.ws.close(code, reason);
+    }
+
+    addEventListener<K extends keyof WebSocketEventMap>(type: K, listener: (this: WebSocket, ev: WebSocketEventMap[K]) => unknown): void {
+        this.eventListeners[type].push(listener);
+    }
+
+    removeEventListener<K extends keyof WebSocketEventMap>(type: K, listener: (this: WebSocket, ev: WebSocketEventMap[K]) => unknown): void {
+        const listeners = this.eventListeners[type];
+        const index = listeners.indexOf(listener);
+        if (index !== -1) {
+            listeners.splice(index, 1);
+        }
+    }
+}

package/src/api/permission/extension.ts

@@ -100,4 +100,8 @@ export class PermissionExtension {
     public has(permissionIdentifier: Identifier): boolean {
         return this.permissions.has(permissionIdentifier);
     }
+
+    public required(permissionIdentifier: Identifier): boolean {
+        return this.requiredPermissions.has(permissionIdentifier);
+    }
 }

package/src/api/registry/extension.ts

@@ -9,7 +9,7 @@ import { EndpointType } from '../endpoint/endpoint.js';
 import { type Extension, ExtensionType } from '../extension.js';
 
 import { RegisterPacket, RegistryPacket } from './packets.js';
-import { type Registry, RegistryType } from './registry.js';
+import { type Registry, RegistryType, Writable } from './registry.js';
 
 export class RegistryExtension implements Extension {
     public readonly type: ExtensionType<RegistryExtension> = REGISTRY_EXTENSION_TYPE;
@@ -162,6 +162,51 @@ class RegistryImpl<T> implements Registry<T> {
             permissions: this.type.permissions,
         });
     }
+
+    public compatSvelte(): Writable<T> {
+        let ready = false;
+        let value: T = this.value;
+        const listeners = new Set<(value: T) => void>();
+        this.listen((newValue) => {
+            ready = true;
+            value = newValue;
+            listeners.forEach((run) => {
+                run(value);
+            });
+        });
+        return {
+            set: (value: T) => {
+                if (!ready) {
+                    throw new Error(`Registry ${this.type.id.key()} is not ready`);
+                }
+                this.set(value);
+            },
+            subscribe: (run) => {
+                listeners.add(run);
+                run(value);
+                return () => {
+                    listeners.delete(run);
+                };
+            },
+            update: (fn) => {
+                if (!ready) {
+                    throw new Error(`Registry ${this.type.id.key()} is not ready`);
+                }
+                this.update(fn);
+            },
+            wait: () => {
+                return new Promise<T>((resolve) => {
+                    if (ready) {
+                        resolve(value);
+                    } else {
+                        listeners.add(() => {
+                            resolve(value);
+                        });
+                    }
+                });
+            },
+        };
+    }
 }
 
 export const REGISTRY_EXTENSION_TYPE: ExtensionType<RegistryExtension> = new ExtensionType(

package/src/api/registry/registry.ts

@@ -70,4 +70,27 @@ export interface Registry<T> {
     update(fn: (value: T) => PromiseLike<T> | T): Promise<T>;
     modify(fn: (value: T) => PromiseLike<T> | T): Promise<T>;
     listen(fn: (value: T) => void): Unlisten;
+
+    compatSvelte(): Writable<T>;
+}
+
+export type Subscriber<T> = (value: T) => void;
+
+export type Unsubscriber = () => void;
+
+export type Updater<T> = (value: T) => T;
+
+export type StartStopNotifier<T> = (
+    set: (value: T) => void,
+    update: (fn: Updater<T>) => void
+) => void | (() => void);
+
+export interface Readable<T> {
+    subscribe(this: void, run: Subscriber<T>): Unsubscriber;
+}
+
+export interface Writable<T> extends Readable<T> {
+    set(this: void, value: T): void;
+    update(this: void, updater: Updater<T>): void;
+    wait(): Promise<T>;
 }

package/src/api/server/extension.ts

@@ -1,5 +1,6 @@
 import { App, AppJson } from '../../app.js';
 import { Identifier, IdentifierMap } from '../../identifier';
+import { LocalizedText } from '../../localization/localization.js';
 import { Omu } from '../../omu.js';
 import { EndpointType } from '../endpoint/endpoint.js';
 import { ExtensionType, type Extension } from '../extension.js';
@@ -13,6 +14,7 @@ export const SERVER_EXTENSION_TYPE: ExtensionType<ServerExtension> = new Extensi
 
 export interface AppIndexEntry {
     url: string;
+    meta?: AppIndexRegistryMeta;
     added_at: string;
 };
 
@@ -96,8 +98,14 @@ export class SessionObserver {
     }
 }
 
+export type AppIndexRegistryMeta = {
+    name: LocalizedText;
+    note: LocalizedText;
+};
+
 export interface AppIndexRegistryJSON {
     id: string;
+    meta?: AppIndexRegistryMeta;
     apps: Record<string, AppJson>;
 }
 
@@ -105,6 +113,7 @@ export class AppIndexRegistry {
     constructor(
         public id: Identifier,
         public apps: IdentifierMap<App>,
+        public meta: AppIndexRegistryMeta | undefined,
     ) { }
 
     public static fromJSON(json: AppIndexRegistryJSON): AppIndexRegistry {
@@ -121,6 +130,7 @@ export class AppIndexRegistry {
         return new AppIndexRegistry(
             id,
             apps,
+            json.meta,
         );
     }
 }

package/src/index.ts

@@ -6,7 +6,7 @@ export { Omu } from './omu.js';
 export { Serializer } from './serialize';
 export type { Serializable } from './serialize';
 export { BrowserTokenProvider, type SessionParam, type TokenProvider } from './token';
-import { ASSET_DELETE_PERMISSION_ID, ASSET_DOWNLOAD_PERMISSION_ID, ASSET_UPLOAD_PERMISSION_ID } from './api/asset';
+import { ASSET_PERMISSION_ID } from './api/asset';
 import {
     DASHBOARD_APP_INSTALL_PERMISSION_ID,
     DAShBOARD_DRAG_DROP_PERMISSION_ID,
@@ -29,7 +29,7 @@ import { Identifier } from './identifier';
 
 export const OmuPermissions: {
     // Asset API
-    readonly ASSET_DELETE_PERMISSION_ID: Identifier; readonly ASSET_DOWNLOAD_PERMISSION_ID: Identifier; readonly ASSET_UPLOAD_PERMISSION_ID: Identifier;
+    readonly ASSET_PERMISSION_ID: Identifier;
     // Dashboard API
     readonly DASHBOARD_APP_INSTALL_PERMISSION_ID: Identifier; readonly DAShBOARD_DRAG_DROP_PERMISSION_ID: Identifier; readonly DASHBOARD_OPEN_APP_PERMISSION_ID: Identifier; readonly DASHBOARD_SET_PERMISSION_ID: Identifier; readonly DASHBOARD_SPEECH_RECOGNITION_PERMISSION_ID: Identifier; readonly DASHBOARD_WEBVIEW_PERMISSION_ID: Identifier; readonly DASHOBARD_APP_EDIT_PERMISSION_ID: Identifier; readonly DASHOBARD_APP_READ_PERMISSION_ID: Identifier;
     // HTTP API
@@ -50,9 +50,7 @@ export const OmuPermissions: {
     readonly TABLE_PERMISSION_ID: Identifier;
 } = {
     // Asset API
-    ASSET_DELETE_PERMISSION_ID,
-    ASSET_DOWNLOAD_PERMISSION_ID,
-    ASSET_UPLOAD_PERMISSION_ID,
+    ASSET_PERMISSION_ID: ASSET_PERMISSION_ID,
     // Dashboard API
     DASHBOARD_APP_INSTALL_PERMISSION_ID,
     DAShBOARD_DRAG_DROP_PERMISSION_ID,

package/src/version.ts

@@ -1 +1 @@
-export const VERSION = '0.9.26';
+export const VERSION = '0.9.32';