@omujs/omu 0.9.10 → 0.9.27

package/dist/dts/api/signal/packets.d.ts

@@ -0,0 +1,21 @@
+import { Identifier } from "../../identifier";
+import { SignalPermissions, SignalPermissionsJSON } from "./signal.js";
+export declare class SignalPacket {
+	readonly id: Identifier;
+	readonly body: Uint8Array;
+	constructor(id: Identifier, body: Uint8Array);
+	static serialize(packet: SignalPacket): Uint8Array;
+	static deserialize(data: Uint8Array): SignalPacket;
+}
+interface SignalRegisterPacketJSON {
+	id: string;
+	permissions: SignalPermissionsJSON;
+}
+export declare class SignalRegisterPacket {
+	readonly id: Identifier;
+	readonly permissions: SignalPermissions;
+	constructor(id: Identifier, permissions: SignalPermissions);
+	static serialize(packet: SignalRegisterPacket): SignalRegisterPacketJSON;
+	static deserialize(data: SignalRegisterPacketJSON): SignalRegisterPacket;
+}
+export {};

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

@@ -0,0 +1,33 @@
+import type { Unlisten } from "../../event";
+import { Identifier, IntoId } from "../../identifier";
+import type { Serializable } from "../../serialize";
+export interface SignalPermissionsJSON {
+	all?: string;
+	listen?: string;
+	send?: string;
+}
+export interface SignalPermissions {
+	all?: IntoId | undefined;
+	listen?: IntoId | undefined;
+	send?: IntoId | undefined;
+}
+export declare class SignalType<T> {
+	readonly id: Identifier;
+	readonly serializer: Serializable<T, Uint8Array>;
+	readonly permissions: SignalPermissions;
+	constructor(id: Identifier, serializer: Serializable<T, Uint8Array>, permissions: SignalPermissions);
+	static createJson<T>(identifier: IntoId, { name, serializer, permissions }: {
+		name: string;
+		serializer?: Serializable<T, any>;
+		permissions?: SignalPermissions;
+	}): SignalType<T>;
+	static createSerialized<T>(identifier: IntoId, { name, serializer, permissions }: {
+		name: string;
+		serializer: Serializable<T, Uint8Array>;
+		permissions?: SignalPermissions;
+	}): SignalType<T>;
+}
+export interface Signal<T> {
+	listen(handler: (value: T) => void): Unlisten;
+	notify(body: T): void;
+}

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

@@ -0,0 +1,29 @@
+import { Identifier } from "../../identifier";
+import { Omu } from "../../omu";
+import type { JsonType, Serializable } from "../../serialize";
+import type { Extension } from "../extension.js";
+import { ExtensionType } from "../extension.js";
+import type { Table } from "./table.js";
+import { TableType } from "./table.js";
+export declare const TABLE_EXTENSION_TYPE: ExtensionType<TableExtension>;
+export declare const TABLE_PERMISSION_ID: Identifier;
+export declare class TableExtension implements Extension {
+	private readonly omu;
+	readonly type: ExtensionType<TableExtension>;
+	private readonly tableMap;
+	constructor(omu: Omu);
+	private createTable;
+	json<
+		T,
+		D extends JsonType = JsonType
+	>(name: string, options: {
+		key: (item: T) => string;
+		serializer?: Serializable<T, D>;
+	}): Table<T>;
+	serialized<T>(name: string, options: {
+		key: (item: T) => string;
+		serializer: Serializable<T, Uint8Array>;
+	}): Table<T>;
+	get<T>(type: TableType<T>): Table<T>;
+	has(identifier: Identifier): boolean;
+}

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

@@ -0,0 +1,2 @@
+export { TABLE_PERMISSION_ID } from "./extension.js";
+export { TableType, type Table, type TableConfig } from "./table.js";

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

@@ -0,0 +1,65 @@
+import { Identifier } from "../../identifier";
+import type { TableConfig } from "./table.js";
+export declare class TablePacket {
+	readonly id: Identifier;
+	constructor(id: Identifier);
+	static serialize(packet: TablePacket): Uint8Array;
+	static deserialize(data: Uint8Array): TablePacket;
+}
+export declare class TableItemsPacket {
+	readonly id: Identifier;
+	readonly items: Record<string, Uint8Array>;
+	constructor(id: Identifier, items: Record<string, Uint8Array>);
+	static serialize(packet: TableItemsPacket): Uint8Array;
+	static deserialize(data: Uint8Array): TableItemsPacket;
+}
+export declare class TableKeysPacket {
+	readonly id: Identifier;
+	readonly keys: string[];
+	constructor(id: Identifier, keys: string[]);
+	static serialize(packet: TableKeysPacket): Uint8Array;
+	static deserialize(data: Uint8Array): TableKeysPacket;
+}
+export declare class TableProxyPacket {
+	readonly id: Identifier;
+	readonly items: Record<string, Uint8Array>;
+	readonly key: number;
+	constructor(id: Identifier, items: Record<string, Uint8Array>, key: number);
+	static serialize(packet: TableProxyPacket): Uint8Array;
+	static deserialize(data: Uint8Array): TableProxyPacket;
+}
+export declare class TableFetchPacket {
+	readonly id: Identifier;
+	readonly limit: number;
+	readonly backward: boolean;
+	readonly cursor: string | null;
+	constructor(id: Identifier, limit: number, backward?: boolean, cursor?: string | null);
+	static serialize(packet: TableFetchPacket): Uint8Array;
+	static deserialize(data: Uint8Array): TableFetchPacket;
+}
+export declare class TableFetchRangePacket {
+	readonly id: Identifier;
+	readonly start: string;
+	readonly end: string;
+	constructor(id: Identifier, start: string, end: string);
+	static serialize(packet: TableFetchRangePacket): Uint8Array;
+	static deserialize(data: Uint8Array): TableFetchRangePacket;
+}
+export declare class SetConfigPacket {
+	readonly id: Identifier;
+	readonly config: TableConfig;
+	constructor(id: Identifier, config: TableConfig);
+	static serialize(packet: SetConfigPacket): Uint8Array;
+	static deserialize(data: Uint8Array): SetConfigPacket;
+}
+export declare class SetPermissionPacket {
+	readonly id: Identifier;
+	readonly all: Identifier | null;
+	readonly read: Identifier | null;
+	readonly write: Identifier | null;
+	readonly remove: Identifier | null;
+	readonly proxy: Identifier | null;
+	constructor(id: Identifier, all: Identifier | null, read: Identifier | null, write: Identifier | null, remove: Identifier | null, proxy: Identifier | null);
+	static serialize(packet: SetPermissionPacket): Uint8Array;
+	static deserialize(data: Uint8Array): SetPermissionPacket;
+}

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

@@ -0,0 +1,76 @@
+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

@@ -1,42 +1,49 @@
-import { Identifier } from './identifier.js';
-import type { Keyable } from './interface.js';
-import type { Locale } from './localization/locale.js';
-import type { LocalizedText } from './localization/localization.js';
-import type { Model } from './model.js';
+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[];
+	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 AppType = 'app' | 'plugin' | 'dashboard';
 export type AppJson = {
-    id: string;
-    version?: string;
-    url?: string;
-    type?: AppType;
-    metadata?: AppMetadata;
+	id: string;
+	type: AppType;
+	parent_id?: string;
+	version?: string;
+	url?: string;
+	metadata?: AppMetadata;
+	dependencies?: Record<string, DependencySpecifier | string>;
 };
-export declare class App implements Keyable, Model<AppJson> {
-    readonly id: Identifier;
-    readonly version?: string;
-    readonly url?: string;
-    readonly metadata?: AppMetadata;
-    readonly type?: AppType;
-    constructor(id: Identifier | string, options: {
-        version?: string;
-        url?: string;
-        metadata?: AppMetadata;
-        type?: AppType;
-    });
-    key(): string;
-    static fromJson(info: AppJson): App;
-    toJson(): AppJson;
+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;
 }
-//# sourceMappingURL=app.d.ts.map

package/dist/dts/const.d.ts

@@ -1,3 +1,2 @@
 export declare const textEncoder: TextEncoder;
 export declare const textDecoder: TextDecoder;
-//# sourceMappingURL=const.d.ts.map

package/dist/dts/errors.d.ts

@@ -1,31 +1,36 @@
-import { DisconnectType } from './network/packet/packet-types.js';
+import { DisconnectType } from "./network/packet/packet-types.js";
 export declare class OmuError extends Error {
-    constructor(message: string | null);
+	constructor(message: string | null);
 }
 export declare class DisconnectReason extends OmuError {
-    type: DisconnectType;
-    message: string;
-    constructor(type: DisconnectType, message?: string);
+	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);
+	constructor(message: string);
 }
 export declare class PermissionDenied extends DisconnectReason {
-    constructor(message: string);
+	constructor(message: string);
+}
+export declare class AppRemoved extends DisconnectReason {
+	constructor(message: string);
 }
 export declare class InvalidToken extends DisconnectReason {
-    constructor(message: string);
+	constructor(message: string);
 }
 export declare class InvalidOrigin extends DisconnectReason {
-    constructor(message: string);
+	constructor(message: string);
 }
 export declare class InvalidVersion extends DisconnectReason {
-    constructor(message: string);
+	constructor(message: string);
 }
 export declare class InvalidPacket extends DisconnectReason {
-    constructor(message: string);
+	constructor(message: string);
 }
 export declare class InternalError extends DisconnectReason {
-    constructor(message: string);
+	constructor(message: string);
 }
-//# sourceMappingURL=errors.d.ts.map

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,13 @@
+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

@@ -1,44 +1,50 @@
-import type { Keyable } from './interface.js';
-import type { Model } from './model.js';
-export declare class Identifier implements Model<string>, Keyable {
-    readonly namespace: string;
-    readonly path: string[];
-    constructor(namespace: string, ...path: string[]);
-    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;
-    toJson(): string;
-    static fromJson(json: string): Identifier;
-    key(): string;
-    isEqual(other: Identifier): boolean;
-    isSubpathOf(other: Identifier): boolean;
-    join(...path: string[]): Identifier;
+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;
+	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;
-    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]>;
+	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]>;
+	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]>;
 }
-//# sourceMappingURL=identifier.d.ts.map

package/dist/dts/index.d.ts

@@ -1,7 +1,37 @@
-export { App } from './app.js';
-export { Identifier } from './identifier.js';
-export * as interfaces from './interface.js';
-export { Omu } from './omu.js';
-export { Serializer } from './serializer.js';
-export type { Serializable } from './serializer.js';
-//# sourceMappingURL=index.d.ts.map
+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 { BrowserTokenProvider, type SessionParam, type TokenProvider } from "./token";
+import { Identifier } from "./identifier";
+export declare const OmuPermissions: {
+	readonly ASSET_DELETE_PERMISSION_ID: Identifier;
+	readonly ASSET_DOWNLOAD_PERMISSION_ID: Identifier;
+	readonly ASSET_UPLOAD_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/dist/dts/localization/index.d.ts

@@ -1,3 +1,2 @@
-export { LOCALE_NAMES, Locale as Locale } from './locale.js';
-export { LocalizedText, Translations } from './localization.js';
-//# sourceMappingURL=index.d.ts.map
+export { Locale, LOCALE_NAMES } from "./locale.js";
+export type { LocalizedText, Translations } from "./localization.js";