@ai-switch/tauri-plugin-runtime 0.1.0

package/dist/node/fs/promises.d.ts

@@ -0,0 +1,33 @@
+import type { FsPromises } from "./types.js";
+export declare const readFile: {
+    (path: string, options?: import("./types.js").ReadBufferOptions): Promise<import("buffer/index.js").Buffer>;
+    (path: string, options: import("./types.js").ReadTextOptions): Promise<string>;
+    (path: string, options?: import("./types.js").ReadFileOptions): Promise<import("buffer/index.js").Buffer | string>;
+};
+export declare const writeFile: (path: string, data: string | Uint8Array, options?: import("./types.js").WriteFileOptions) => Promise<void>;
+export declare const appendFile: (path: string, data: string | Uint8Array, options?: import("./types.js").AppendFileOptions) => Promise<void>;
+export declare const readdir: {
+    (path: string, options?: {
+        withFileTypes?: false;
+    }): Promise<string[]>;
+    (path: string, options: {
+        withFileTypes: true;
+    }): Promise<import("./types.js").DirectoryEntry[]>;
+    (path: string, options?: import("./types.js").ReaddirOptions): Promise<string[] | import("./types.js").DirectoryEntry[]>;
+};
+export declare const stat: (path: string) => Promise<import("./types.js").FileStats>;
+export declare const mkdir: {
+    (path: string, options?: {
+        recursive?: false;
+    }): Promise<void>;
+    (path: string, options: {
+        recursive: true;
+    }): Promise<string | undefined>;
+    (path: string, options?: import("./types.js").MkdirOptions): Promise<string | undefined>;
+};
+export declare const rename: (from: string, to: string) => Promise<void>;
+export declare const copyFile: (from: string, to: string) => Promise<void>;
+export declare const rm: (path: string, options?: import("./types.js").RemoveOptions) => Promise<void>;
+declare const promises: FsPromises;
+export default promises;
+export type { FsPromises, FsError, FileStats, DirectoryEntry, ReadFileOptions, ReadBufferOptions, ReadTextOptions, WriteFileOptions, AppendFileOptions, ReaddirOptions, MkdirOptions, RemoveOptions } from "./types.js";

package/dist/node/fs/promises.js

@@ -0,0 +1,30 @@
+import {
+  appendFile,
+  copyFile,
+  mkdir,
+  promises_default,
+  readFile,
+  readdir,
+  rename,
+  rm,
+  stat,
+  writeFile
+} from "../../chunk-YI6NQ6WR.js";
+import "../../chunk-K5YWIJN6.js";
+import "../../chunk-PW7XHHWG.js";
+import "../../chunk-RKQEK7DY.js";
+import "../../chunk-WT62GTMC.js";
+import "../../chunk-CFQSUF5W.js";
+import "../../chunk-JSBRDJBE.js";
+export {
+  appendFile,
+  copyFile,
+  promises_default as default,
+  mkdir,
+  readFile,
+  readdir,
+  rename,
+  rm,
+  stat,
+  writeFile
+};

package/dist/node/fs/transfer.d.ts

@@ -0,0 +1,7 @@
+import { Buffer } from "../buffer.js";
+import { type FileContext } from "./lifecycle.js";
+import { type FsBackend } from "./backend.js";
+export declare function createTransferClient(backend: FsBackend): {
+    read(context: FileContext, path: string): Promise<Buffer>;
+    write(context: FileContext, path: string, data: Buffer, mode: "w" | "wx" | "a" | "ax"): Promise<void>;
+};

package/dist/node/fs/types.d.ts

@@ -0,0 +1,86 @@
+import type { Buffer } from "../buffer.js";
+import type { PluginApi, ConnectionState } from "../../plugin/types.js";
+import type { Unsubscribe } from "../../protocol/wire.js";
+import type { FsCapabilityMessage } from "../../protocol/generated/types.generated.js";
+export type CapabilityCall = PluginApi["call"];
+export type FsMethod = Extract<FsCapabilityMessage, {
+    direction: "request";
+}>["method"];
+export type FsRequest<M extends FsMethod> = Extract<FsCapabilityMessage, {
+    direction: "request";
+    method: M;
+}>["value"];
+export type FsResult<M extends FsMethod> = Extract<FsCapabilityMessage, {
+    direction: "result";
+    method: M;
+}>["value"];
+export type ReadBufferOptions = null | {
+    encoding?: null;
+};
+export type ReadTextOptions = "utf8" | {
+    encoding: "utf8";
+};
+export type ReadFileOptions = ReadBufferOptions | ReadTextOptions;
+export type WriteFileOptions = "utf8" | null | {
+    encoding?: "utf8";
+    flag?: "w" | "wx";
+};
+export type AppendFileOptions = "utf8" | null | {
+    encoding?: "utf8";
+    flag?: "a" | "ax";
+};
+export interface DirectoryEntry {
+    readonly name: string;
+    isFile(): boolean;
+    isDirectory(): boolean;
+}
+export interface FileStats {
+    readonly size: number;
+    readonly mtimeMs: number;
+    isFile(): boolean;
+    isDirectory(): boolean;
+}
+export interface MkdirOptions {
+    recursive?: boolean;
+}
+export interface RemoveOptions {
+    recursive?: boolean;
+    force?: boolean;
+}
+export interface ReaddirOptions {
+    withFileTypes?: boolean;
+}
+export interface FsError extends Error {
+    code: string;
+    syscall: string;
+    path?: string;
+    dest?: string;
+}
+export interface FsClientOptions {
+    onConnectionChange?: (listener: (state: ConnectionState) => void) => Unsubscribe;
+}
+export interface FsPromises {
+    readFile(path: string, options?: ReadBufferOptions): Promise<Buffer>;
+    readFile(path: string, options: ReadTextOptions): Promise<string>;
+    readFile(path: string, options?: ReadFileOptions): Promise<Buffer | string>;
+    writeFile(path: string, data: string | Uint8Array, options?: WriteFileOptions): Promise<void>;
+    appendFile(path: string, data: string | Uint8Array, options?: AppendFileOptions): Promise<void>;
+    readdir(path: string, options?: {
+        withFileTypes?: false;
+    }): Promise<string[]>;
+    readdir(path: string, options: {
+        withFileTypes: true;
+    }): Promise<DirectoryEntry[]>;
+    readdir(path: string, options?: ReaddirOptions): Promise<string[] | DirectoryEntry[]>;
+    stat(path: string): Promise<FileStats>;
+    mkdir(path: string, options?: {
+        recursive?: false;
+    }): Promise<void>;
+    mkdir(path: string, options: {
+        recursive: true;
+    }): Promise<string | undefined>;
+    mkdir(path: string, options?: MkdirOptions): Promise<string | undefined>;
+    rename(from: string, to: string): Promise<void>;
+    copyFile(from: string, to: string): Promise<void>;
+    rm(path: string, options?: RemoveOptions): Promise<void>;
+}

package/dist/node/fs.d.ts

@@ -0,0 +1,36 @@
+import promises from "./fs/promises.js";
+declare const fs: import("./fs.js").CallbackFs;
+export { promises };
+export declare const readFile: {
+    (path: string, callback: import("./fs.js").ValueCallback<import("buffer/index.js").Buffer>): void;
+    (path: string, options: import("./fs/types.js").ReadBufferOptions | undefined, callback: import("./fs.js").ValueCallback<import("buffer/index.js").Buffer>): void;
+    (path: string, options: import("./fs/types.js").ReadTextOptions, callback: import("./fs.js").ValueCallback<string>): void;
+    (path: string, options: import("./fs/types.js").ReadFileOptions | undefined, callback: import("./fs.js").ValueCallback<import("buffer/index.js").Buffer | string>): void;
+}, writeFile: {
+    (path: string, data: string | Uint8Array, callback: import("./fs.js").VoidCallback): void;
+    (path: string, data: string | Uint8Array, options: import("./fs/types.js").WriteFileOptions | undefined, callback: import("./fs.js").VoidCallback): void;
+}, appendFile: {
+    (path: string, data: string | Uint8Array, callback: import("./fs.js").VoidCallback): void;
+    (path: string, data: string | Uint8Array, options: import("./fs/types.js").AppendFileOptions | undefined, callback: import("./fs.js").VoidCallback): void;
+}, readdir: {
+    (path: string, callback: import("./fs.js").ValueCallback<string[]>): void;
+    (path: string, options: {
+        withFileTypes?: false;
+    } | undefined, callback: import("./fs.js").ValueCallback<string[]>): void;
+    (path: string, options: {
+        withFileTypes: true;
+    }, callback: import("./fs.js").ValueCallback<import("./fs.js").DirectoryEntry[]>): void;
+    (path: string, options: import("./fs/types.js").ReaddirOptions | undefined, callback: import("./fs.js").ValueCallback<string[] | import("./fs.js").DirectoryEntry[]>): void;
+}, stat: (path: string, callback: import("./fs.js").ValueCallback<import("./fs.js").FileStats>) => void, mkdir: {
+    (path: string, callback: import("./fs.js").VoidCallback): void;
+    (path: string, options: {
+        recursive?: false;
+    } | undefined, callback: import("./fs.js").VoidCallback): void;
+    (path: string, options: import("./fs/types.js").MkdirOptions, callback: import("./fs.js").ValueCallback<string | undefined>): void;
+}, rename: (from: string, to: string, callback: import("./fs.js").VoidCallback) => void, copyFile: (from: string, to: string, callback: import("./fs.js").VoidCallback) => void, rm: {
+    (path: string, callback: import("./fs.js").VoidCallback): void;
+    (path: string, options: import("./fs/types.js").RemoveOptions | undefined, callback: import("./fs.js").VoidCallback): void;
+}, readFileSync: import("./fs/callback-types.js").UnsupportedSync, writeFileSync: import("./fs/callback-types.js").UnsupportedSync, appendFileSync: import("./fs/callback-types.js").UnsupportedSync, readdirSync: import("./fs/callback-types.js").UnsupportedSync, statSync: import("./fs/callback-types.js").UnsupportedSync, mkdirSync: import("./fs/callback-types.js").UnsupportedSync, renameSync: import("./fs/callback-types.js").UnsupportedSync, copyFileSync: import("./fs/callback-types.js").UnsupportedSync, rmSync: import("./fs/callback-types.js").UnsupportedSync;
+export default fs;
+export type { CallbackFs, ValueCallback, VoidCallback } from "./fs/callback-types.js";
+export type { FsPromises, FsError, DirectoryEntry, FileStats } from "./fs/types.js";

package/dist/node/fs.js

@@ -0,0 +1,92 @@
+import {
+  promises_default,
+  unsupportedSync
+} from "../chunk-YI6NQ6WR.js";
+import "../chunk-K5YWIJN6.js";
+import "../chunk-PW7XHHWG.js";
+import "../chunk-RKQEK7DY.js";
+import "../chunk-WT62GTMC.js";
+import "../chunk-CFQSUF5W.js";
+import "../chunk-JSBRDJBE.js";
+
+// src/node/fs/callbacks.ts
+function createCallbackFs(promises) {
+  const methods = ["readFile", "writeFile", "appendFile", "readdir", "stat", "mkdir", "rename", "copyFile", "rm"];
+  const wrappers = { promises };
+  for (const method of methods) {
+    wrappers[method] = (...args) => {
+      const callback = args.pop();
+      if (typeof callback !== "function") throw new TypeError("A filesystem callback function is required.");
+      const deliver = (...values) => {
+        try {
+          callback(...values);
+        } catch (error) {
+          setTimeout(() => {
+            throw error;
+          }, 0);
+        }
+      };
+      let result;
+      try {
+        result = Reflect.apply(promises[method], promises, args);
+      } catch (error) {
+        result = Promise.reject(error);
+      }
+      void result.then((value) => {
+        if (method === "writeFile" || method === "appendFile" || method === "rename" || method === "copyFile" || method === "rm") deliver(null);
+        else deliver(null, value);
+      }, (error) => {
+        if (method === "readFile" || method === "readdir" || method === "stat" || method === "mkdir") deliver(error, void 0);
+        else deliver(error);
+      });
+    };
+    wrappers[`${method}Sync`] = unsupportedSync;
+  }
+  return Object.freeze(wrappers);
+}
+
+// src/node/fs.ts
+var fs = createCallbackFs(promises_default);
+var {
+  readFile,
+  writeFile,
+  appendFile,
+  readdir,
+  stat,
+  mkdir,
+  rename,
+  copyFile,
+  rm,
+  readFileSync,
+  writeFileSync,
+  appendFileSync,
+  readdirSync,
+  statSync,
+  mkdirSync,
+  renameSync,
+  copyFileSync,
+  rmSync
+} = fs;
+var fs_default = fs;
+export {
+  appendFile,
+  appendFileSync,
+  copyFile,
+  copyFileSync,
+  fs_default as default,
+  mkdir,
+  mkdirSync,
+  promises_default as promises,
+  readFile,
+  readFileSync,
+  readdir,
+  readdirSync,
+  rename,
+  renameSync,
+  rm,
+  rmSync,
+  stat,
+  statSync,
+  writeFile,
+  writeFileSync
+};

package/dist/node/path.d.ts

@@ -0,0 +1,20 @@
+/** Pure string helpers, not filesystem authorization. All relative paths use /data. */
+export declare const join: (...parts: string[]) => string;
+export declare const resolve: (...parts: string[]) => string;
+export declare const normalize: (path: string) => string;
+export declare const dirname: (path: string) => string;
+export declare const basename: (path: string, suffix?: string) => string;
+export declare const extname: (path: string) => string;
+export declare const isAbsolute: (path: string) => boolean;
+export declare const relative: (from: string, to: string) => string;
+declare const _default: Readonly<{
+    join: (...parts: string[]) => string;
+    resolve: (...parts: string[]) => string;
+    normalize: (path: string) => string;
+    dirname: (path: string) => string;
+    basename: (path: string, suffix?: string) => string;
+    extname: (path: string) => string;
+    relative: (from: string, to: string) => string;
+    isAbsolute: (path: string) => boolean;
+}>;
+export default _default;