@omujs/omu 0.9.47 → 0.9.49

package/dist/dts/api/table/table.d.ts

@@ -0,0 +1,75 @@
+import type { EventEmitter, Unlisten } from '../../event';
+import { Identifier, IntoId } from '../../identifier';
+import type { JsonType, Serializable } from '../../serialize';
+export type TableConfig = {
+    cache_size: number;
+};
+export interface Table<T> {
+    readonly cache: ReadonlyMap<string, T>;
+    readonly event: TableEvents<T>;
+    get(key: string): Promise<T | undefined>;
+    getMany(...keys: string[]): Promise<Map<string, T>>;
+    add(...item: T[]): Promise<void>;
+    update(...item: T[]): Promise<void>;
+    remove(...items: T[]): Promise<void>;
+    clear(): Promise<void>;
+    has(key: string): Promise<boolean>;
+    hasMany<T extends Record<string, unknown>>(...keys: (keyof T)[]): Promise<{
+        [key in keyof T]: boolean;
+    }>;
+    hasAll(...keys: string[]): Promise<boolean>;
+    hasAny(...keys: string[]): Promise<boolean>;
+    fetchItems({ limit, backward, cursor, }: {
+        limit: number;
+        backward?: boolean;
+        cursor?: string;
+    }): Promise<Map<string, T>>;
+    fetchRange({ start, end }: {
+        start: string;
+        end: string;
+    }): Promise<Map<string, T>>;
+    fetchAll(): Promise<Map<string, T>>;
+    iterate({ backward, cursor }: {
+        backward?: boolean;
+        cursor?: string;
+    }): AsyncIterable<T>;
+    size(): Promise<number>;
+    proxy(proxy: (item: T) => T | undefined): Unlisten;
+    setCacheSize(size: number): void;
+    setConfig(config: TableConfig): void;
+    setPermissions(permissions: TablePermissions): void;
+    listen(listener?: (items: Map<string, T>) => void): Unlisten;
+}
+export type TableEvents<T> = {
+    add: EventEmitter<[Map<string, T>]>;
+    update: EventEmitter<[Map<string, T>]>;
+    remove: EventEmitter<[Map<string, T>]>;
+    clear: EventEmitter<[]>;
+    cacheUpdate: EventEmitter<[Map<string, T>]>;
+};
+export type TablePermissions = {
+    all?: Identifier;
+    read?: Identifier;
+    write?: Identifier;
+    remove?: Identifier;
+    proxy?: Identifier;
+};
+export declare class TableType<T> {
+    id: Identifier;
+    serializer: Serializable<T, Uint8Array>;
+    keyFunction: (item: T) => string;
+    permissions?: TablePermissions | undefined;
+    constructor(id: Identifier, serializer: Serializable<T, Uint8Array>, keyFunction: (item: T) => string, permissions?: TablePermissions | undefined);
+    static createJson<T, D extends JsonType = JsonType>(identifier: IntoId, { name, key, permissions, serializer, }: {
+        name: string;
+        key: (item: T) => string;
+        permissions?: TablePermissions;
+        serializer?: Serializable<T, D>;
+    }): TableType<T>;
+    static createSerialized<T>(identifier: IntoId, { name, key, permissions, serializer, }: {
+        name: string;
+        key: (item: T) => string;
+        permissions?: TablePermissions;
+        serializer: Serializable<T, Uint8Array>;
+    }): TableType<T>;
+}

package/dist/dts/app.d.ts

@@ -0,0 +1,49 @@
+import { Identifier, IntoId } from './identifier';
+import type { Locale } from './localization/locale.js';
+import type { LocalizedText } from './localization/localization.js';
+export type AppMetadata = {
+    locale: Locale;
+    name?: LocalizedText;
+    icon?: LocalizedText;
+    description?: LocalizedText;
+    image?: LocalizedText;
+    site?: LocalizedText;
+    repository?: LocalizedText;
+    authors?: LocalizedText;
+    license?: LocalizedText;
+    tags?: string[];
+};
+export type AppType = 'app' | 'service' | 'remote' | 'plugin' | 'dashboard';
+export type DependencySpecifier = {
+    version: string;
+    index?: string;
+};
+export type AppJson = {
+    id: string;
+    type: AppType;
+    parent_id?: string;
+    version?: string;
+    url?: string;
+    metadata?: AppMetadata;
+    dependencies?: Record<string, DependencySpecifier | string>;
+};
+export declare class App {
+    readonly id: Identifier;
+    readonly type: AppType;
+    readonly parentId?: Identifier;
+    readonly version?: string;
+    readonly url?: string;
+    readonly metadata?: AppMetadata;
+    readonly dependencies: Record<string, DependencySpecifier | string>;
+    constructor(id: IntoId, options: {
+        type?: AppType;
+        parentId?: IntoId;
+        version?: string;
+        url?: string;
+        metadata?: AppMetadata;
+        dependencies?: Record<string, DependencySpecifier | string>;
+    });
+    static deserialize(info: AppJson): App;
+    static serialize(data: App): AppJson;
+    join(...paths: string[]): App;
+}

package/dist/dts/const.d.ts

@@ -0,0 +1,2 @@
+export declare const textEncoder: TextEncoder;
+export declare const textDecoder: TextDecoder;

package/dist/dts/errors.d.ts

@@ -0,0 +1,36 @@
+import { DisconnectType } from './network/packet/packet-types.js';
+export declare class OmuError extends Error {
+    constructor(message: string | null);
+}
+export declare class DisconnectReason extends OmuError {
+    type: DisconnectType;
+    message: string;
+    constructor(type: DisconnectType, message?: string);
+}
+export declare class ServerRestart extends DisconnectReason {
+    constructor(message: string);
+}
+export declare class AnotherConnection extends DisconnectReason {
+    constructor(message: string);
+}
+export declare class PermissionDenied extends DisconnectReason {
+    constructor(message: string);
+}
+export declare class AppRemoved extends DisconnectReason {
+    constructor(message: string);
+}
+export declare class InvalidToken extends DisconnectReason {
+    constructor(message: string);
+}
+export declare class InvalidOrigin extends DisconnectReason {
+    constructor(message: string);
+}
+export declare class InvalidVersion extends DisconnectReason {
+    constructor(message: string);
+}
+export declare class InvalidPacket extends DisconnectReason {
+    constructor(message: string);
+}
+export declare class InternalError extends DisconnectReason {
+    constructor(message: string);
+}

package/dist/dts/event/index.d.ts

@@ -0,0 +1,6 @@
+export type Unlisten = () => void;
+export declare class EventEmitter<P extends Array<any>> {
+    private readonly listeners;
+    listen(listener: (...args: P) => any): Unlisten;
+    emit(...args: P): Promise<void>;
+}

package/dist/dts/helper.d.ts

@@ -0,0 +1,10 @@
+type Ok<T> = {
+    ok: true;
+    data: T;
+};
+type Err<E> = {
+    ok: false;
+    data: E;
+};
+export declare function tryCatch<T, E = Error>(func: () => T): Ok<T> | Err<E>;
+export {};

package/dist/dts/identifier.d.ts

@@ -0,0 +1,51 @@
+import type { ExtensionType } from './api';
+import { App } from './app';
+export type IntoId = Identifier | string | ExtensionType | App;
+export declare class Identifier {
+    readonly namespace: string;
+    readonly path: string[];
+    constructor(namespace: string, ...path: string[]);
+    static serialize(identifier: Identifier): string;
+    static deserialize(json: string): Identifier;
+    static from(id: IntoId): Identifier;
+    static fromOptional(id: IntoId | undefined | null): Identifier | undefined;
+    static validate(namespace: string, path: string[]): void;
+    static format(namespace: string, ...path: string[]): string;
+    static fromKey(key: string): Identifier;
+    static fromUrl(url: string | URL): Identifier;
+    static namespaceFromUrl(url: string | URL): string;
+    get base(): Identifier;
+    toJson(): string;
+    static fromJson(json: string): Identifier;
+    key(): string;
+    isEqual(other: Identifier): boolean;
+    isNamespaceEqual(other: Identifier): boolean;
+    isSubpathOf(other: Identifier): boolean;
+    join(...path: string[]): Identifier;
+}
+export declare class IdentifierMap<T> {
+    private readonly map;
+    constructor(entries?: Iterable<[Identifier, T]>);
+    get size(): number;
+    set(identifier: Identifier, value: T): void;
+    get(identifier: Identifier): T | undefined;
+    has(identifier: Identifier): boolean;
+    delete(identifier: Identifier): void;
+    clear(): void;
+    keys(): IterableIterator<Identifier>;
+    values(): IterableIterator<T>;
+    entries(): IterableIterator<[Identifier, T]>;
+    [Symbol.iterator](): IterableIterator<[Identifier, T]>;
+}
+export declare class IdentifierSet {
+    private readonly set;
+    get size(): number;
+    add(identifier: Identifier): void;
+    has(identifier: Identifier): boolean;
+    delete(identifier: Identifier): void;
+    clear(): void;
+    keys(): IterableIterator<Identifier>;
+    values(): IterableIterator<Identifier>;
+    entries(): IterableIterator<[Identifier, Identifier]>;
+    [Symbol.iterator](): IterableIterator<[Identifier, Identifier]>;
+}

package/dist/dts/index.d.ts

@@ -0,0 +1,36 @@
+export { AppIndexRegistry, type AppIndexRegistryJSON } from './api/server';
+export { App, AppMetadata } from './app.js';
+export { DisconnectReason } from './errors.js';
+export { Identifier, IdentifierMap, IdentifierSet, IntoId } from './identifier';
+export * as network from './network';
+export { Omu } from './omu.js';
+export { Serializer } from './serialize';
+export type { Serializable } from './serialize';
+export { BrowserSession, type SessionParam, type SessioTokenProvider as TokenProvider } from './token';
+import { Identifier } from './identifier';
+export declare const OmuPermissions: {
+    readonly ASSET_PERMISSION_ID: Identifier;
+    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;
+    readonly HTTP_REQUEST_PERMISSION_ID: Identifier;
+    readonly I18N_GET_LOCALES_PERMISSION_ID: Identifier;
+    readonly I18N_SET_LOCALES_PERMISSION_ID: Identifier;
+    readonly LOGGER_LOG_PERMISSION_ID: Identifier;
+    readonly PLUGIN_MANAGE_PACKAGE_PERMISSION_ID: Identifier;
+    readonly PLUGIN_READ_PACKAGE_PERMISSION_ID: Identifier;
+    readonly REGISTRY_PERMISSION_ID: Identifier;
+    readonly SERVER_APPS_READ_PERMISSION_ID: Identifier;
+    readonly SERVER_SHUTDOWN_PERMISSION_ID: Identifier;
+    readonly TRUSTED_ORIGINS_GET_PERMISSION_ID: Identifier;
+    readonly TRUSTED_ORIGINS_SET_PERMISSION_ID: Identifier;
+    readonly GENERATE_TOKEN_PERMISSION_ID: Identifier;
+    readonly REMOTE_APP_REQUEST_PERMISSION_ID: Identifier;
+    readonly SESSIONS_READ_PERMISSION_ID: Identifier;
+    readonly TABLE_PERMISSION_ID: Identifier;
+};

package/{src/localization/index.ts → dist/dts/localization/index.d.ts}

@@ -1,3 +1,2 @@
 export { Locale as Locale, LOCALE_NAMES } from './locale.js';
 export type { LocalizedText, Translations } from './localization.js';
-