@simplysm/capacitor-plugin-file-system 13.0.0-beta.6 → 13.0.1

package/dist/core-common/src/utils/xml.d.ts

@@ -1,36 +0,0 @@
-/**
- * XML 변환 유틸리티
- */
-import type { XmlBuilderOptions } from "fast-xml-parser";
-/**
- * XML 문자열을 객체로 파싱
- * @param str XML 문자열
- * @param options 옵션
- * @param options.stripTagPrefix 태그 prefix 제거 여부 (namespace)
- * @returns 파싱된 객체. 구조:
- *   - 속성: `$` 객체에 그룹화
- *   - 텍스트 노드: `_` 키에 저장
- *   - 자식 요소: 배열로 변환 (루트 요소 제외)
- * @example
- * xmlParse('<root id="1"><item>hello</item></root>');
- * // { root: { $: { id: "1" }, item: [{ _: "hello" }] } }
- */
-export declare function xmlParse(str: string, options?: {
-    stripTagPrefix?: boolean;
-}): unknown;
-/**
- * 객체를 XML 문자열로 직렬화
- * @param obj 직렬화할 객체
- * @param options fast-xml-parser XmlBuilderOptions (선택)
- * @returns XML 문자열
- * @example
- * xmlStringify({
- *   root: {
- *     $: { id: "1" },
- *     item: [{ _: "hello" }, { _: "world" }],
- *   },
- * });
- * // '<root id="1"><item>hello</item><item>world</item></root>'
- */
-export declare function xmlStringify(obj: unknown, options?: XmlBuilderOptions): string;
-//# sourceMappingURL=xml.d.ts.map

package/dist/core-common/src/utils/xml.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"xml.d.ts","sourceRoot":"","sources":["../../../../../core-common/src/utils/xml.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAKzD;;;;;;;;;;;;GAYG;AACH,wBAAgB,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE;IAAE,cAAc,CAAC,EAAE,OAAO,CAAA;CAAE,GAAG,OAAO,CAarF;AAMD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,iBAAiB,GAAG,MAAM,CAS9E"}

package/dist/core-common/src/zip/sd-zip.d.ts

@@ -1,80 +0,0 @@
-import type { Bytes } from "../common.types";
-export interface ZipArchiveProgress {
-    fileName: string;
-    totalSize: number;
-    extractedSize: number;
-}
-/**
- * ZIP 아카이브 처리 클래스
- *
- * ZIP 파일의 읽기, 쓰기, 압축/해제를 처리합니다.
- * 내부 캐시를 사용하여 동일 파일의 중복 압축 해제를 방지합니다.
- *
- * @example
- * // ZIP 파일 읽기
- * await using archive = new ZipArchive(zipBytes);
- * const content = await archive.get("file.txt");
- *
- * @example
- * // ZIP 파일 생성
- * await using archive = new ZipArchive();
- * archive.write("file.txt", textBytes);
- * archive.write("data.json", jsonBytes);
- * const zipBytes = await archive.compress();
- *
- * @example
- * // 전체 압축 해제 (진행률 표시)
- * await using archive = new ZipArchive(zipBytes);
- * const files = await archive.extractAll((progress) => {
- *   console.log(`${progress.fileName}: ${progress.extractedSize}/${progress.totalSize}`);
- * });
- */
-export declare class ZipArchive {
-    private readonly _reader?;
-    private readonly _cache;
-    private _entries?;
-    /**
-     * ZipArchive 생성
-     * @param data ZIP 데이터 (생략 시 새 아카이브 생성)
-     */
-    constructor(data?: Blob | Bytes);
-    private _getEntries;
-    /**
-     * 모든 파일을 압축 해제
-     * @param progressCallback 진행률 콜백
-     */
-    extractAll(progressCallback?: (progress: ZipArchiveProgress) => void): Promise<Map<string, Bytes | undefined>>;
-    /**
-     * 특정 파일 압축 해제
-     * @param fileName 파일 이름
-     */
-    get(fileName: string): Promise<Bytes | undefined>;
-    /**
-     * 파일 존재 여부 확인
-     * @param fileName 파일 이름
-     */
-    exists(fileName: string): Promise<boolean>;
-    /**
-     * 파일 쓰기 (캐시에 저장)
-     * @param fileName 파일 이름
-     * @param bytes 파일 내용
-     */
-    write(fileName: string, bytes: Bytes): void;
-    /**
-     * 캐시된 파일들을 ZIP으로 압축
-     *
-     * @remarks
-     * 내부적으로 `extractAll()`을 호출하여 모든 파일을 메모리에 로드한 후 압축합니다.
-     * 대용량 ZIP 파일의 경우 메모리 사용량에 주의가 필요합니다.
-     */
-    compress(): Promise<Bytes>;
-    /**
-     * 리더 닫기 및 캐시 정리
-     */
-    close(): Promise<void>;
-    /**
-     * await using 지원
-     */
-    [Symbol.asyncDispose](): Promise<void>;
-}
-//# sourceMappingURL=sd-zip.d.ts.map

package/dist/core-common/src/zip/sd-zip.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"sd-zip.d.ts","sourceRoot":"","sources":["../../../../../core-common/src/zip/sd-zip.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAC;AAE7C,MAAM,WAAW,kBAAkB;IACjC,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,aAAa,EAAE,MAAM,CAAC;CACvB;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,qBAAa,UAAU;IACrB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAC,CAA0B;IACnD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAwC;IAC/D,OAAO,CAAC,QAAQ,CAAC,CAA6D;IAE9E;;;OAGG;gBACS,IAAI,CAAC,EAAE,IAAI,GAAG,KAAK;YAUjB,WAAW;IAQzB;;;OAGG;IACG,UAAU,CAAC,gBAAgB,CAAC,EAAE,CAAC,QAAQ,EAAE,kBAAkB,KAAK,IAAI,GAAG,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,KAAK,GAAG,SAAS,CAAC,CAAC;IAkDpH;;;OAGG;IACG,GAAG,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,KAAK,GAAG,SAAS,CAAC;IAwBvD;;;OAGG;IACG,MAAM,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAgBhD;;;;OAIG;IACH,KAAK,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,GAAG,IAAI;IAM3C;;;;;;OAMG;IACG,QAAQ,IAAI,OAAO,CAAC,KAAK,CAAC;IAiBhC;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAK5B;;OAEG;IACG,CAAC,MAAM,CAAC,YAAY,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC;CAI7C"}

package/src/FileSystem.ts

@@ -1,126 +0,0 @@
-import { registerPlugin } from "@capacitor/core";
-import type { IFileInfo, IFileSystemPlugin, TStorage } from "./IFileSystemPlugin";
-import type { Bytes } from "@simplysm/core-common";
-import { bytesToBase64, bytesFromBase64 } from "@simplysm/core-common";
-
-const FileSystemPlugin = registerPlugin<IFileSystemPlugin>("FileSystem", {
-  web: async () => {
-    const { FileSystemWeb } = await import("./web/FileSystemWeb");
-    return new FileSystemWeb();
-  },
-});
-
-/**
- * 파일 시스템 접근 플러그인
- * - Android 11+: MANAGE_EXTERNAL_STORAGE 권한으로 전체 파일 시스템 접근
- * - Android 10-: READ/WRITE_EXTERNAL_STORAGE 권한
- * - Browser: IndexedDB 기반 에뮬레이션
- */
-export abstract class FileSystem {
-  /**
-   * 권한 확인
-   */
-  static async hasPermission(): Promise<boolean> {
-    const result = await FileSystemPlugin.hasPermission();
-    return result.granted;
-  }
-
-  /**
-   * 권한 요청
-   * - Android 11+: 설정 화면으로 이동
-   * - Android 10-: 권한 다이얼로그 표시
-   */
-  static async requestPermission(): Promise<void> {
-    await FileSystemPlugin.requestPermission();
-  }
-
-  /**
-   * 디렉토리 읽기
-   */
-  static async readdir(dirPath: string): Promise<IFileInfo[]> {
-    const result = await FileSystemPlugin.readdir({ path: dirPath });
-    return result.files;
-  }
-
-  /**
-   * 저장소 경로 얻기
-   * @param type 저장소 타입
-   * - external: 외부 저장소 루트 (Environment.getExternalStorageDirectory)
-   * - externalFiles: 앱 전용 외부 파일 디렉토리
-   * - externalCache: 앱 전용 외부 캐시 디렉토리
-   * - externalMedia: 앱 전용 외부 미디어 디렉토리
-   * - appData: 앱 데이터 디렉토리
-   * - appFiles: 앱 파일 디렉토리
-   * - appCache: 앱 캐시 디렉토리
-   */
-  static async getStoragePath(type: TStorage): Promise<string> {
-    const result = await FileSystemPlugin.getStoragePath({ type });
-    return result.path;
-  }
-
-  /**
-   * 파일 URI 얻기 (FileProvider)
-   */
-  static async getFileUri(filePath: string): Promise<string> {
-    const result = await FileSystemPlugin.getFileUri({ path: filePath });
-    return result.uri;
-  }
-
-  /**
-   * 파일 쓰기
-   */
-  static async writeFile(filePath: string, data: string | Bytes): Promise<void> {
-    if (typeof data !== "string") {
-      // Bytes (Uint8Array) - cross-realm 환경에서도 안전하게 동작
-      await FileSystemPlugin.writeFile({
-        path: filePath,
-        data: bytesToBase64(data),
-        encoding: "base64",
-      });
-    } else {
-      await FileSystemPlugin.writeFile({
-        path: filePath,
-        data,
-        encoding: "utf8",
-      });
-    }
-  }
-
-  /**
-   * 파일 읽기 (UTF-8 문자열)
-   */
-  static async readFileString(filePath: string): Promise<string> {
-    const result = await FileSystemPlugin.readFile({ path: filePath, encoding: "utf8" });
-    return result.data;
-  }
-
-  /**
-   * 파일 읽기 (Bytes)
-   */
-  static async readFileBytes(filePath: string): Promise<Bytes> {
-    const result = await FileSystemPlugin.readFile({ path: filePath, encoding: "base64" });
-    return bytesFromBase64(result.data);
-  }
-
-  /**
-   * 파일/디렉토리 삭제 (재귀)
-   */
-  static async remove(targetPath: string): Promise<void> {
-    await FileSystemPlugin.remove({ path: targetPath });
-  }
-
-  /**
-   * 디렉토리 생성 (재귀)
-   */
-  static async mkdir(targetPath: string): Promise<void> {
-    await FileSystemPlugin.mkdir({ path: targetPath });
-  }
-
-  /**
-   * 존재 여부 확인
-   */
-  static async exists(targetPath: string): Promise<boolean> {
-    const result = await FileSystemPlugin.exists({ path: targetPath });
-    return result.exists;
-  }
-}

package/src/IFileSystemPlugin.ts

@@ -1,26 +0,0 @@
-export type TStorage =
-  | "external"
-  | "externalFiles"
-  | "externalCache"
-  | "externalMedia"
-  | "appData"
-  | "appFiles"
-  | "appCache";
-
-export interface IFileInfo {
-  name: string;
-  isDirectory: boolean;
-}
-
-export interface IFileSystemPlugin {
-  hasPermission(): Promise<{ granted: boolean }>;
-  requestPermission(): Promise<void>;
-  readdir(options: { path: string }): Promise<{ files: IFileInfo[] }>;
-  getStoragePath(options: { type: TStorage }): Promise<{ path: string }>;
-  getFileUri(options: { path: string }): Promise<{ uri: string }>;
-  writeFile(options: { path: string; data: string; encoding?: "utf8" | "base64" }): Promise<void>;
-  readFile(options: { path: string; encoding?: "utf8" | "base64" }): Promise<{ data: string }>;
-  remove(options: { path: string }): Promise<void>;
-  mkdir(options: { path: string }): Promise<void>;
-  exists(options: { path: string }): Promise<{ exists: boolean }>;
-}

package/src/index.ts

@@ -1,2 +0,0 @@
-export * from "./FileSystem";
-export * from "./IFileSystemPlugin";

package/src/web/FileSystemWeb.ts

@@ -1,107 +0,0 @@
-import { WebPlugin } from "@capacitor/core";
-import type { IFileInfo, IFileSystemPlugin, TStorage } from "../IFileSystemPlugin";
-import { VirtualFileSystem } from "./VirtualFileSystem";
-import { bytesToBase64, bytesFromBase64 } from "@simplysm/core-common";
-
-export class FileSystemWeb extends WebPlugin implements IFileSystemPlugin {
-  private readonly _fs = new VirtualFileSystem("capacitor_web_virtual_fs");
-  private readonly _textEncoder = new TextEncoder();
-  private readonly _textDecoder = new TextDecoder();
-
-  async hasPermission(): Promise<{ granted: boolean }> {
-    return Promise.resolve({ granted: true });
-  }
-
-  async requestPermission(): Promise<void> {}
-
-  async readdir(options: { path: string }): Promise<{ files: IFileInfo[] }> {
-    const entry = await this._fs.getEntry(options.path);
-    if (!entry || entry.kind !== "dir") {
-      throw new Error("Directory does not exist");
-    }
-    const files = await this._fs.listChildren(options.path);
-    return { files };
-  }
-
-  async getStoragePath(options: { type: TStorage }): Promise<{ path: string }> {
-    const base = "/webfs";
-    let storagePath: string;
-    switch (options.type) {
-      case "external":
-        storagePath = base + "/external";
-        break;
-      case "externalFiles":
-        storagePath = base + "/externalFiles";
-        break;
-      case "externalCache":
-        storagePath = base + "/externalCache";
-        break;
-      case "externalMedia":
-        storagePath = base + "/externalMedia";
-        break;
-      case "appData":
-        storagePath = base + "/appData";
-        break;
-      case "appFiles":
-        storagePath = base + "/appFiles";
-        break;
-      case "appCache":
-        storagePath = base + "/appCache";
-        break;
-      default:
-        throw new Error("Unknown storage type: " + options.type);
-    }
-    await this._fs.ensureDir(storagePath);
-    return { path: storagePath };
-  }
-
-  /**
-   * 파일의 Blob URL을 반환합니다.
-   * @warning 반환된 URI는 사용 후 반드시 `URL.revokeObjectURL(uri)`를 호출하여 해제해야 합니다.
-   * 해제하지 않으면 메모리 누수가 발생할 수 있습니다.
-   */
-  async getFileUri(options: { path: string }): Promise<{ uri: string }> {
-    const entry = await this._fs.getEntry(options.path);
-    if (!entry || entry.kind !== "file" || entry.dataBase64 == null) {
-      throw new Error("File not found: " + options.path);
-    }
-    const bytes = bytesFromBase64(entry.dataBase64);
-    const blob = new Blob([bytes]);
-    return { uri: URL.createObjectURL(blob) };
-  }
-
-  async writeFile(options: { path: string; data: string; encoding?: "utf8" | "base64" }): Promise<void> {
-    const idx = options.path.lastIndexOf("/");
-    const dir = idx === -1 ? "." : options.path.substring(0, idx) || "/";
-    await this._fs.ensureDir(dir);
-    const dataBase64 =
-      options.encoding === "base64" ? options.data : bytesToBase64(this._textEncoder.encode(options.data));
-    await this._fs.putEntry({ path: options.path, kind: "file", dataBase64 });
-  }
-
-  async readFile(options: { path: string; encoding?: "utf8" | "base64" }): Promise<{ data: string }> {
-    const entry = await this._fs.getEntry(options.path);
-    if (!entry || entry.kind !== "file" || entry.dataBase64 == null) {
-      throw new Error("File not found: " + options.path);
-    }
-    const data =
-      options.encoding === "base64" ? entry.dataBase64 : this._textDecoder.decode(bytesFromBase64(entry.dataBase64));
-    return { data };
-  }
-
-  async remove(options: { path: string }): Promise<void> {
-    const ok = await this._fs.deleteByPrefix(options.path);
-    if (!ok) {
-      throw new Error("Deletion failed");
-    }
-  }
-
-  async mkdir(options: { path: string }): Promise<void> {
-    await this._fs.ensureDir(options.path);
-  }
-
-  async exists(options: { path: string }): Promise<{ exists: boolean }> {
-    const entry = await this._fs.getEntry(options.path);
-    return { exists: !!entry };
-  }
-}

package/src/web/IndexedDbStore.ts

@@ -1,88 +0,0 @@
-export interface IStoreConfig {
-  name: string;
-  keyPath: string;
-}
-
-export class IndexedDbStore {
-  constructor(
-    private readonly _dbName: string,
-    private readonly _dbVersion: number,
-    private readonly _storeConfigs: IStoreConfig[],
-  ) {}
-
-  async open(): Promise<IDBDatabase> {
-    return new Promise((resolve, reject) => {
-      const req = indexedDB.open(this._dbName, this._dbVersion);
-      req.onupgradeneeded = () => {
-        const db = req.result;
-        for (const config of this._storeConfigs) {
-          if (!db.objectStoreNames.contains(config.name)) {
-            db.createObjectStore(config.name, { keyPath: config.keyPath });
-          }
-        }
-      };
-      req.onsuccess = () => resolve(req.result);
-      req.onerror = () => reject(req.error);
-      req.onblocked = () => reject(new Error("Database blocked by another connection"));
-    });
-  }
-
-  async withStore<T>(
-    storeName: string,
-    mode: IDBTransactionMode,
-    fn: (store: IDBObjectStore) => Promise<T>,
-  ): Promise<T> {
-    const db = await this.open();
-    return new Promise((resolve, reject) => {
-      const tx = db.transaction(storeName, mode);
-      const store = tx.objectStore(storeName);
-      let result: T;
-      Promise.resolve(fn(store))
-        .then((r) => {
-          result = r;
-        })
-        .catch((err) => {
-          db.close();
-          reject(err);
-        });
-      tx.oncomplete = () => {
-        db.close();
-        resolve(result);
-      };
-      tx.onerror = () => {
-        db.close();
-        reject(tx.error);
-      };
-    });
-  }
-
-  async get<T>(storeName: string, key: IDBValidKey): Promise<T | undefined> {
-    return this.withStore(storeName, "readonly", async (store) => {
-      return new Promise((resolve, reject) => {
-        const req = store.get(key);
-        req.onsuccess = () => resolve(req.result as T | undefined);
-        req.onerror = () => reject(req.error);
-      });
-    });
-  }
-
-  async put(storeName: string, value: unknown): Promise<void> {
-    return this.withStore(storeName, "readwrite", async (store) => {
-      return new Promise((resolve, reject) => {
-        const req = store.put(value);
-        req.onsuccess = () => resolve();
-        req.onerror = () => reject(req.error);
-      });
-    });
-  }
-
-  async getAll<T>(storeName: string): Promise<T[]> {
-    return this.withStore(storeName, "readonly", async (store) => {
-      return new Promise((resolve, reject) => {
-        const req = store.getAll();
-        req.onsuccess = () => resolve(req.result as T[]);
-        req.onerror = () => reject(req.error);
-      });
-    });
-  }
-}

package/src/web/VirtualFileSystem.ts

@@ -1,105 +0,0 @@
-import type { IFileInfo } from "../IFileSystemPlugin";
-import { IndexedDbStore } from "./IndexedDbStore";
-
-interface FsEntry {
-  path: string;
-  kind: "file" | "dir";
-  dataBase64?: string;
-}
-
-export class VirtualFileSystem {
-  private readonly _STORE_NAME = "entries";
-  private readonly _db: IndexedDbStore;
-
-  constructor(dbName: string) {
-    this._db = new IndexedDbStore(dbName, 1, [{ name: this._STORE_NAME, keyPath: "path" }]);
-  }
-
-  async getEntry(filePath: string): Promise<FsEntry | undefined> {
-    return this._db.get<FsEntry>(this._STORE_NAME, filePath);
-  }
-
-  async putEntry(entry: FsEntry): Promise<void> {
-    return this._db.put(this._STORE_NAME, entry);
-  }
-
-  async deleteByPrefix(pathPrefix: string): Promise<boolean> {
-    return this._db.withStore(this._STORE_NAME, "readwrite", async (store) => {
-      return new Promise((resolve, reject) => {
-        const req = store.openCursor();
-        let found = false;
-        req.onsuccess = () => {
-          const cursor = req.result;
-          if (!cursor) {
-            resolve(found);
-            return;
-          }
-          const key = String(cursor.key);
-          if (key === pathPrefix || key.startsWith(pathPrefix + "/")) {
-            found = true;
-            cursor.delete();
-          }
-          cursor.continue();
-        };
-        req.onerror = () => reject(req.error);
-      });
-    });
-  }
-
-  /**
-   * 디렉토리의 직접 자식 목록을 반환합니다.
-   * @param dirPath 조회할 디렉토리 경로
-   * @returns 자식 파일/디렉토리 목록
-   * @note 암시적 디렉토리 처리: 파일 경로만 존재하고 디렉토리 엔트리가 없는 경우에도
-   * 중간 경로는 디렉토리로 판정됩니다. 예: "/a/b/c.txt"만 저장된 상태에서
-   * listChildren("/a") 호출 시 "b"는 isDirectory: true로 반환됩니다.
-   */
-  async listChildren(dirPath: string): Promise<IFileInfo[]> {
-    const prefix = dirPath === "/" ? "/" : dirPath + "/";
-    return this._db.withStore(this._STORE_NAME, "readonly", async (store) => {
-      return new Promise((resolve, reject) => {
-        const req = store.openCursor();
-        const map = new Map<string, boolean>();
-        req.onsuccess = () => {
-          const cursor = req.result;
-          if (!cursor) {
-            resolve(Array.from(map.entries()).map(([name, isDirectory]) => ({ name, isDirectory })));
-            return;
-          }
-          const key = String(cursor.key);
-          if (key.startsWith(prefix)) {
-            const rest = key.slice(prefix.length);
-            if (rest) {
-              const segments = rest.split("/").filter(Boolean);
-              if (segments.length > 0) {
-                const firstSeg = segments[0];
-                if (!map.has(firstSeg)) {
-                  const isDir = segments.length > 1 || (cursor.value as FsEntry).kind === "dir";
-                  map.set(firstSeg, isDir);
-                }
-              }
-            }
-          }
-          cursor.continue();
-        };
-        req.onerror = () => reject(req.error);
-      });
-    });
-  }
-
-  async ensureDir(dirPath: string): Promise<void> {
-    if (dirPath === "/") {
-      await this.putEntry({ path: "/", kind: "dir" });
-      return;
-    }
-    const segments = dirPath.split("/").filter(Boolean);
-    let acc = "";
-    for (const seg of segments) {
-      acc += "/" + seg;
-      const existing = await this.getEntry(acc);
-      if (!existing) {
-        await this.putEntry({ path: acc, kind: "dir" });
-      }
-    }
-  }
-}