@utoo/web 0.0.1-alpha.10

package/esm/index.d.ts

@@ -0,0 +1,21 @@
+import { Dirent, MountOpt, ProjectEndpoint } from "./type";
+export declare class Project implements ProjectEndpoint {
+    #private;
+    private remote;
+    constructor(opt: MountOpt & {
+        worker?: Worker;
+    });
+    install(packageLock: string): Promise<void>;
+    build(): Promise<void>;
+    readFile(path: string, encoding?: "utf8"): Promise<any>;
+    writeFile(path: string, content: string | Uint8Array, encoding?: "utf8"): Promise<void>;
+    copyFile(src: string, dst: string): Promise<void>;
+    readdir(path: string, options?: {
+        recursive?: boolean;
+    }): Promise<Dirent[]>;
+    mkdir(path: string, options?: {
+        recursive?: boolean;
+    }): Promise<void>;
+    static fork(channel: MessageChannel): ProjectEndpoint;
+}
+export * from "./type";

package/esm/index.js

@@ -0,0 +1,103 @@
+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 _Project_tunnel;
+import * as comlink from "comlink";
+import { Fork, HandShake } from "./message";
+import { Dirent } from "./type";
+let ProjectWorker;
+const ConnectedPorts = new Set();
+export class Project {
+    constructor(opt) {
+        var _a, _b;
+        _Project_tunnel.set(this, void 0);
+        const { cwd, worker, wasmUrl } = opt;
+        const { port1, port2 } = new MessageChannel();
+        (_a = this.remote) !== null && _a !== void 0 ? _a : (this.remote = comlink.wrap(port1));
+        if (!ProjectWorker) {
+            ProjectWorker =
+                worker || new Worker(new URL("./worker", import.meta.url));
+            self.addEventListener("message", (e) => {
+                const port = e.ports[0];
+                if (e.data === Fork && !ConnectedPorts.has(port)) {
+                    ProjectWorker.postMessage(HandShake, [port]);
+                }
+            });
+        }
+        ProjectWorker.postMessage(HandShake, [port2]);
+        __classPrivateFieldSet(this, _Project_tunnel, (_b = __classPrivateFieldGet(this, _Project_tunnel, "f")) !== null && _b !== void 0 ? _b : this.remote.mount({ cwd, wasmUrl }), "f");
+    }
+    async install(packageLock) {
+        await __classPrivateFieldGet(this, _Project_tunnel, "f");
+        return await this.remote.install(packageLock);
+    }
+    async build() {
+        await __classPrivateFieldGet(this, _Project_tunnel, "f");
+        return await this.remote.build();
+    }
+    async readFile(path, encoding) {
+        await __classPrivateFieldGet(this, _Project_tunnel, "f");
+        return (await this.remote.readFile(path, encoding));
+    }
+    async writeFile(path, content, encoding) {
+        await __classPrivateFieldGet(this, _Project_tunnel, "f");
+        return await this.remote.writeFile(path, content, encoding);
+    }
+    async copyFile(src, dst) {
+        await __classPrivateFieldGet(this, _Project_tunnel, "f");
+        return await this.remote.copyFile(src, dst);
+    }
+    async readdir(path, options) {
+        await __classPrivateFieldGet(this, _Project_tunnel, "f");
+        const dirEntry = (await this.remote.readdir(path, options));
+        return dirEntry.map((e) => new Dirent(e));
+    }
+    async mkdir(path, options) {
+        await __classPrivateFieldGet(this, _Project_tunnel, "f");
+        return await this.remote.mkdir(path, options);
+    }
+    static fork(channel) {
+        self.postMessage(Fork, {
+            targetOrigin: "*",
+            transfer: [channel.port2],
+        });
+        return new ForkedProject(channel.port1);
+    }
+}
+_Project_tunnel = new WeakMap();
+class ForkedProject {
+    constructor(port) {
+        var _a;
+        (_a = this.endpoint) !== null && _a !== void 0 ? _a : (this.endpoint = comlink.wrap(port));
+    }
+    async install(packageLock) {
+        return await this.endpoint.install(packageLock);
+    }
+    async build() {
+        return await this.endpoint.build();
+    }
+    async readFile(path, encoding) {
+        return (await this.endpoint.readFile(path, encoding));
+    }
+    async writeFile(path, content, encoding) {
+        return await this.endpoint.writeFile(path, content, encoding);
+    }
+    async copyFile(src, dst) {
+        return await this.endpoint.copyFile(src, dst);
+    }
+    async readdir(path, options) {
+        return await this.endpoint.readdir(path, options);
+    }
+    async mkdir(path, options) {
+        return await this.endpoint.mkdir(path, options);
+    }
+}
+export * from "./type";

package/esm/message.d.ts

@@ -0,0 +1,2 @@
+export declare const HandShake = "__handshake__";
+export declare const Fork = "__fork__";

package/esm/message.js

@@ -0,0 +1,2 @@
+export const HandShake = "__handshake__";
+export const Fork = "__fork__";

package/esm/type.d.ts

@@ -0,0 +1,30 @@
+import { DirEntryType } from "./utoo";
+export interface RawDirent {
+    name: string;
+    type: DirEntryType;
+}
+export declare class Dirent {
+    private rawDirent;
+    name: string;
+    constructor(rawDirent: RawDirent);
+    isDirectory(): boolean;
+    isFile(): boolean;
+}
+export interface ProjectEndpoint {
+    install: (packageLock: string) => Promise<void>;
+    build: () => Promise<void>;
+    readFile(path: string): Promise<Uint8Array>;
+    readFile(path: string, encoding?: "utf8"): Promise<string>;
+    writeFile(path: string, content: string | Uint8Array, encoding?: "utf8"): Promise<void>;
+    readdir(path: string, options?: {
+        recursive?: boolean;
+    }): Promise<Dirent[]>;
+    mkdir(path: string, options?: {
+        recursive?: boolean;
+    }): Promise<void>;
+    copyFile(src: string, dst: string): Promise<void>;
+}
+export interface MountOpt {
+    cwd: string;
+    wasmUrl?: string;
+}

package/esm/type.js

@@ -0,0 +1,12 @@
+export class Dirent {
+    constructor(rawDirent) {
+        this.rawDirent = rawDirent;
+        this.name = this.rawDirent.name;
+    }
+    isDirectory() {
+        return this.rawDirent.type === "directory";
+    }
+    isFile() {
+        return this.rawDirent.type === "file";
+    }
+}

package/esm/utoo/index.d.ts

@@ -0,0 +1,107 @@
+export function init_pack(): void;
+/**
+ * Entry point for web workers
+ * @param {number} ptr
+ */
+export function wasm_thread_entry_point(ptr: number): void;
+export class CreateSyncAccessHandleOptions {
+    static __wrap(ptr: any): any;
+    __destroy_into_raw(): number | undefined;
+    __wbg_ptr: number | undefined;
+    free(): void;
+}
+export class DirEntry {
+    static __wrap(ptr: any): any;
+    toJSON(): {
+        name: string;
+        type: DirEntryType;
+    };
+    toString(): string;
+    __destroy_into_raw(): number | undefined;
+    __wbg_ptr: number | undefined;
+    free(): void;
+    /**
+     * @param {string} arg0
+     */
+    set name(arg0: string);
+    /**
+     * @returns {string}
+     */
+    get name(): string;
+    /**
+     * @param {DirEntryType} arg0
+     */
+    set type(arg0: DirEntryType);
+    /**
+     * @returns {DirEntryType}
+     */
+    get type(): DirEntryType;
+}
+export class Project {
+    /**
+     * @param {string} cwd
+     */
+    constructor(cwd: string);
+    __destroy_into_raw(): number;
+    __wbg_ptr: number;
+    free(): void;
+    /**
+     * @returns {string}
+     */
+    get cwd(): string;
+    /**
+     * @param {string} package_lock
+     * @returns {Promise<void>}
+     */
+    install(package_lock: string): Promise<void>;
+    /**
+     * @returns {Promise<any>}
+     */
+    build(): Promise<any>;
+    /**
+     * @param {string} path
+     * @returns {Promise<Uint8Array>}
+     */
+    read(path: string): Promise<Uint8Array>;
+    /**
+     * @param {string} path
+     * @returns {Promise<string>}
+     */
+    readToString(path: string): Promise<string>;
+    /**
+     * @param {string} path
+     * @param {Uint8Array} content
+     * @returns {Promise<void>}
+     */
+    write(path: string, content: Uint8Array): Promise<void>;
+    /**
+     * @param {string} path
+     * @param {string} content
+     * @returns {Promise<void>}
+     */
+    writeString(path: string, content: string): Promise<void>;
+    /**
+     * @param {string} path
+     * @returns {Promise<DirEntry[]>}
+     */
+    readDir(path: string): Promise<DirEntry[]>;
+    /**
+     * @param {string} path
+     * @returns {Promise<void>}
+     */
+    createDir(path: string): Promise<void>;
+    /**
+     * @param {string} path
+     * @returns {Promise<void>}
+     */
+    createDirAll(path: string): Promise<void>;
+    /**
+     * @param {string} src
+     * @param {string} dst
+     * @returns {Promise<void>}
+     */
+    copyFile(src: string, dst: string): Promise<void>;
+}
+export default __wbg_init;
+export function initSync(module: any, memory: any): any;
+declare function __wbg_init(module_or_path: any, memory: any): Promise<any>;