orgnote-api 0.20.2 → 0.40.9

package/utils/to-error.d.ts

@@ -0,0 +1,6 @@
+import type { Result } from 'neverthrow';
+import { ResultAsync } from 'neverthrow';
+type MapperOrMsg<E> = ((e: unknown) => E) | string;
+export declare function to<R, TThis = unknown, A extends any[] = any[], E = Error>(fn: (this: TThis, ...args: A) => Promise<R>, mapErrorOrMsg?: MapperOrMsg<E>): (this: TThis, ...args: A) => ResultAsync<R, E>;
+export declare function to<R, TThis = unknown, A extends any[] = any[], E = Error>(fn: (this: TThis, ...args: A) => R, mapErrorOrMsg?: MapperOrMsg<E>): (this: TThis, ...args: A) => Result<R, E>;
+export {};

package/utils/to-error.js

@@ -0,0 +1,33 @@
+import { ResultAsync, ok, err } from 'neverthrow';
+import { isPresent } from "./nullable-guards.js";
+const defaultToError = (e) => (e instanceof Error ? e : new Error(String(e)));
+function isPromiseLike(x) {
+    return (typeof x === 'object' &&
+        isPresent(x) &&
+        'then' in x &&
+        typeof x.then === 'function');
+}
+function resolveMapper(map) {
+    if (typeof map === 'function')
+        return map;
+    if (typeof map === 'string') {
+        const msg = map;
+        return (e) => new Error(msg, { cause: e instanceof Error ? e : new Error(String(e)) });
+    }
+    return defaultToError;
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function to(fn, mapErrorOrMsg) {
+    const mapError = resolveMapper(mapErrorOrMsg);
+    return function (...args) {
+        try {
+            const out = fn.apply(this, args);
+            if (isPromiseLike(out))
+                return ResultAsync.fromPromise(out, mapError);
+            return ok(out);
+        }
+        catch (e) {
+            return err(mapError(e));
+        }
+    };
+}

package/utils/toml.d.ts

@@ -0,0 +1,3 @@
+import { BaseIssue, BaseSchema, InferOutput } from 'valibot';
+export declare function parseToml<T = unknown, S extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | undefined = undefined>(content: string, schema?: S): S extends BaseSchema<unknown, unknown, BaseIssue<unknown>> ? InferOutput<S> : T;
+export declare function stringifyToml(data: unknown): string;

package/utils/toml.js

@@ -0,0 +1,31 @@
+import { parse, stringify } from 'smol-toml';
+import { safeParse } from 'valibot';
+export function parseToml(content, schema) {
+    try {
+        const res = parse(content);
+        if (!schema) {
+            return res;
+        }
+        const validationResult = safeParse(schema, res);
+        if (validationResult.success) {
+            return validationResult.output;
+        }
+        throw new TypeError('Invalid config format', {
+            cause: validationResult.issues,
+        });
+    }
+    catch (e) {
+        if (e instanceof TypeError) {
+            throw e;
+        }
+        throw new SyntaxError('Invalid TOML format', { cause: e });
+    }
+}
+export function stringifyToml(data) {
+    try {
+        return stringify(data);
+    }
+    catch (e) {
+        throw new Error('Failed to stringify TOML', { cause: e });
+    }
+}

package/utils/with-root.d.ts

@@ -0,0 +1 @@
+export declare function withRoot(path: string): string;

package/utils/with-root.js

@@ -0,0 +1,6 @@
+export function withRoot(path) {
+    if (path.startsWith('/')) {
+        return path;
+    }
+    return `/${path}`;
+}

package/websocket/client.d.ts

@@ -0,0 +1,24 @@
+import { Logger } from '../models/logger.js';
+export interface WebSocketEvent<T = unknown> {
+    type: string;
+    payload: T;
+}
+export type EventHandler<T = unknown> = (payload: T) => void;
+export declare class WebSocketClient {
+    private readonly url;
+    private readonly logger;
+    private readonly webSocketImpl?;
+    private socket;
+    private handlers;
+    private token;
+    socketId: string | null;
+    constructor(url: string, logger: Logger, webSocketImpl?: unknown);
+    connect(token: string): void;
+    disconnect(): void;
+    on<T>(type: string, handler: EventHandler<T>): void;
+    off<T>(type: string, handler: EventHandler<T>): void;
+    private onOpen;
+    private onMessage;
+    private onClose;
+    private onError;
+}

package/websocket/client.js

@@ -0,0 +1,83 @@
+import ReconnectingWebSocket from 'partysocket/ws';
+export class WebSocketClient {
+    url;
+    logger;
+    webSocketImpl;
+    socket = null;
+    handlers = new Map();
+    token = null;
+    socketId = null;
+    constructor(url, logger, webSocketImpl) {
+        this.url = url;
+        this.logger = logger;
+        this.webSocketImpl = webSocketImpl;
+    }
+    connect(token) {
+        if (this.socket && this.token === token && this.socket.readyState === this.socket.OPEN) {
+            return;
+        }
+        if (this.socket) {
+            this.disconnect();
+        }
+        this.token = token;
+        if (!this.socketId) {
+            this.socketId = crypto.randomUUID();
+        }
+        const url = `${this.url}?token=${this.token}&socket_id=${this.socketId}`;
+        try {
+            this.socket = new ReconnectingWebSocket(url, [], {
+                WebSocket: this.webSocketImpl,
+            });
+            this.socket.addEventListener('open', this.onOpen.bind(this));
+            this.socket.addEventListener('message', this.onMessage.bind(this));
+            this.socket.addEventListener('close', this.onClose.bind(this));
+            this.socket.addEventListener('error', this.onError.bind(this));
+        }
+        catch (e) {
+            this.logger.error('WebSocket connection failed', e);
+        }
+    }
+    disconnect() {
+        if (this.socket) {
+            this.socket.close();
+            this.socket = null;
+        }
+    }
+    on(type, handler) {
+        if (!this.handlers.has(type)) {
+            this.handlers.set(type, []);
+        }
+        this.handlers.get(type)?.push(handler);
+    }
+    off(type, handler) {
+        const handlers = this.handlers.get(type);
+        if (!handlers) {
+            return;
+        }
+        const index = handlers.indexOf(handler);
+        if (index !== -1) {
+            handlers.splice(index, 1);
+        }
+    }
+    onOpen() {
+        this.logger.info('WebSocket connected');
+    }
+    onMessage(event) {
+        try {
+            const data = JSON.parse(event.data);
+            const handlers = this.handlers.get(data.type);
+            if (handlers) {
+                handlers.forEach((h) => h(data.payload));
+            }
+        }
+        catch (e) {
+            this.logger.error('Failed to parse WebSocket message', e);
+        }
+    }
+    onClose() {
+        this.logger.info('WebSocket disconnected');
+    }
+    onError(event) {
+        this.logger.error('WebSocket error', event);
+    }
+}

package/models/file-tree.d.ts

@@ -1,12 +0,0 @@
-export interface FileNode {
-    name: string;
-    id?: string;
-    filePath: string[];
-    type: 'file' | 'directory';
-    meta?: {
-        color?: string;
-        icon?: string;
-        [key: string]: unknown;
-    };
-    children?: FileNode[];
-}

package/tools/__tests__/join.spec.js

@@ -1,24 +0,0 @@
-import { test, expect } from 'vitest';
-import { join } from "../join-path.js";
-test('Should join file paths', () => {
-    const samples = [
-        ['dir1', 'subdir2', 'file'],
-        ['dir2/', '/file'],
-        ['/dri3', 'subdir2/', 'file'],
-        ['file'],
-    ];
-    samples.forEach((sample) => {
-        const result = join(...sample);
-        expect(result).toMatchSnapshot();
-    });
-});
-test('Should not take slashes from the path array into account.', () => {
-    const path = ['/', 'this', '/', 'is-path', 'qwe'];
-    const result = join(...path);
-    expect(result).toBe('this/is-path/qwe');
-});
-test('Should not join empty string with additional slash', () => {
-    const path = ['', 'file'];
-    const result = join(...path);
-    expect(result).toBe('file');
-});

package/tools/join-path.d.ts

@@ -1 +0,0 @@
-export declare function join(...path: string[]): string;

package/tools/join-path.js

@@ -1,7 +0,0 @@
-export function join(...path) {
-    return path
-        .filter((p) => p !== '/' && p)
-        .join('/')
-        .replace(/\/+/g, '/')
-        .replace(/\/+$/, '');
-}

package/tools/mock-server.d.ts

@@ -1 +0,0 @@
-export declare const mockServer: <T extends (...params: any[]) => any>(fn?: T, defaultValue?: ReturnType<T>) => (...params: Parameters<T>) => ReturnType<T>;

package/tools/mock-server.js

@@ -1,12 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-export const mockServer = (fn, defaultValue) => {
-    if (!fn) {
-        return (() => { });
-    }
-    return (...params) => {
-        if (process.env.CLIENT) {
-            return fn(...params);
-        }
-        return defaultValue;
-    };
-};