@vrtmrz/livesync-commonlib 0.1.0-rc.0

package/dist/serviceModules/ServiceDatabaseFileAccessBase.js

@@ -0,0 +1,306 @@
+import { shouldBeIgnored, isPlainText, stripAllPrefixes } from "../string_and_binary/path.js";
+import { LOG_LEVEL_VERBOSE } from "octagonal-wheels/common/logger";
+import { serialized } from "octagonal-wheels/concurrency/lock_v2";
+import { ServiceModuleBase } from "./ServiceModuleBase.js";
+import { EVENT_FILE_SAVED } from "../events/coreEvents.js";
+import { getDatabasePathFromUXFileInfo, getStoragePathFromUXFileInfo, isInternalMetadata } from "../common/typeUtils.js";
+import { createBlob, createTextBlob, determineTypeFromBlob, isDocContentSame, readContent } from "../common/utils.js";
+import { ICHeader } from "../common/models/fileaccess.const.js";
+class ServiceDatabaseFileAccessBase extends ServiceModuleBase {
+  events;
+  vault;
+  storageAccess;
+  path;
+  database;
+  constructor(services) {
+    super(services);
+    this.events = services.events;
+    this.vault = services.vault;
+    this.storageAccess = services.storageAccess;
+    this.database = services.database;
+    this.path = services.path;
+  }
+  async checkIsTargetFile(file) {
+    const path = getStoragePathFromUXFileInfo(file);
+    if (!await this.vault.isTargetFile(path)) {
+      this._log(`File is not target: ${path}`, LOG_LEVEL_VERBOSE);
+      return false;
+    }
+    if (shouldBeIgnored(path)) {
+      this._log(`File should be ignored: ${path}`, LOG_LEVEL_VERBOSE);
+      return false;
+    }
+    return true;
+  }
+  async delete(file, rev) {
+    if (!await this.checkIsTargetFile(file)) {
+      return true;
+    }
+    const fullPath = getDatabasePathFromUXFileInfo(file);
+    try {
+      this._log(`deleteDB By path:${fullPath}`);
+      return await this.deleteFromDBbyPath(fullPath, rev);
+    } catch (ex) {
+      this._log(`Failed to delete ${fullPath}`);
+      this._log(ex, LOG_LEVEL_VERBOSE);
+      return false;
+    }
+  }
+  async createChunks(file, force = false, skipCheck) {
+    return await this.__store(file, force, skipCheck, true);
+  }
+  async store(file, force = false, skipCheck) {
+    return await this.__store(file, force, skipCheck, false);
+  }
+  async storeAsConflictedRevision(file, currentRev, skipCheck) {
+    const conflictBaseRev = await this.getParentRev(file, currentRev);
+    if (!conflictBaseRev) {
+      this._log(`Could not find parent revision for ${file.path} (${currentRev})`, LOG_LEVEL_VERBOSE);
+      return false;
+    }
+    return await this.__store(file, true, skipCheck, false, conflictBaseRev);
+  }
+  async storeContent(path, content) {
+    const blob = createTextBlob(content);
+    const bytes = (await blob.arrayBuffer()).byteLength;
+    const isInternal = path.startsWith(".") ? true : void 0;
+    const dummyUXFileInfo = {
+      name: path.split("/").pop(),
+      path,
+      stat: {
+        size: bytes,
+        ctime: Date.now(),
+        mtime: Date.now(),
+        type: "file"
+      },
+      body: blob,
+      isInternal
+    };
+    return await this.__store(dummyUXFileInfo, true, false, false);
+  }
+  async __store(file, force = false, skipCheck, onlyChunks, conflictBaseRev) {
+    if (!skipCheck) {
+      if (!await this.checkIsTargetFile(file)) {
+        return true;
+      }
+    }
+    if (!file) {
+      this._log("File seems bad", LOG_LEVEL_VERBOSE);
+      return false;
+    }
+    const isPlain = isPlainText(file.name);
+    const possiblyLarge = !isPlain;
+    const content = file.body;
+    const datatype = determineTypeFromBlob(content);
+    const idPrefix = file.isInternal ? ICHeader : "";
+    const fullPath = getStoragePathFromUXFileInfo(file);
+    const fullPathOnDB = getDatabasePathFromUXFileInfo(file);
+    if (possiblyLarge) this._log(`Processing: ${fullPath}`, LOG_LEVEL_VERBOSE);
+    if (file.isInternal) {
+      if (file.deleted) {
+        file.stat = {
+          size: 0,
+          ctime: Date.now(),
+          mtime: Date.now(),
+          type: "file"
+        };
+      } else if (file.stat == void 0) {
+        const stat = await this.storageAccess.statHidden(file.path);
+        if (!stat) {
+          this._log(`Internal file not found: ${fullPath}`, LOG_LEVEL_VERBOSE);
+          return false;
+        }
+        file.stat = stat;
+      }
+    }
+    const idMain = await this.path.path2id(fullPath);
+    const id = idPrefix + idMain;
+    const d = {
+      _id: id,
+      path: fullPathOnDB,
+      data: content,
+      ctime: file.stat.ctime,
+      mtime: file.stat.mtime,
+      size: file.stat.size,
+      children: [],
+      datatype,
+      type: datatype,
+      eden: {}
+    };
+    const msg = `STORAGE -> DB (${datatype}) `;
+    const isNotChanged = await serialized("file-" + fullPath, async () => {
+      if (conflictBaseRev) {
+        return false;
+      }
+      if (force) {
+        this._log(msg + "Force writing " + fullPath, LOG_LEVEL_VERBOSE);
+        return false;
+      }
+      try {
+        const old = await this.database.localDatabase.getDBEntry(d.path, void 0, false, true, false);
+        if (old !== false) {
+          const oldData = { data: old.data, deleted: old._deleted || old.deleted };
+          const newData = { data: d.data, deleted: d._deleted || d.deleted };
+          if (oldData.deleted != newData.deleted) return false;
+          if (!await isDocContentSame(old.data, newData.data)) return false;
+          this._log(
+            msg + "Skipped (not changed) " + fullPath + (d._deleted || d.deleted ? " (deleted)" : ""),
+            LOG_LEVEL_VERBOSE
+          );
+          this.path.markChangesAreSame(old, d.mtime, old.mtime);
+          return true;
+        }
+      } catch (ex) {
+        this._log(
+          msg + "Error, Could not check the diff for the old one." + (force ? "force writing." : "") + fullPath + (d._deleted || d.deleted ? " (deleted)" : ""),
+          LOG_LEVEL_VERBOSE
+        );
+        this._log(ex, LOG_LEVEL_VERBOSE);
+        return !force;
+      }
+      return false;
+    });
+    if (isNotChanged) {
+      this._log(msg + " Skip " + fullPath, LOG_LEVEL_VERBOSE);
+      return true;
+    }
+    const ret = await this.database.localDatabase.putDBEntry(d, onlyChunks, conflictBaseRev);
+    if (ret !== false) {
+      this._log(msg + fullPath);
+      this.events.emitEvent(EVENT_FILE_SAVED);
+    }
+    return ret != false;
+  }
+  async getParentRev(file, rev) {
+    const filename = getDatabasePathFromUXFileInfo(file);
+    try {
+      const doc = await this.database.localDatabase.getDBEntryMeta(filename, { rev, revs: true }, true);
+      if (doc === false) {
+        return false;
+      }
+      const revisions = doc._revisions;
+      if (!revisions || revisions.ids.length < 2) {
+        return false;
+      }
+      return `${revisions.start - 1}-${revisions.ids[1]}`;
+    } catch (ex) {
+      this._log(`Could not read revision history for ${filename} (${rev})`, LOG_LEVEL_VERBOSE);
+      this._log(ex, LOG_LEVEL_VERBOSE);
+      return false;
+    }
+  }
+  async hasContentInRevisionHistory(file, content, currentRev) {
+    if (!await this.checkIsTargetFile(file)) {
+      return true;
+    }
+    const filename = getDatabasePathFromUXFileInfo(file);
+    try {
+      const doc = await this.database.localDatabase.getDBEntryMeta(
+        filename,
+        { rev: currentRev, revs_info: true },
+        true
+      );
+      if (doc === false) {
+        return false;
+      }
+      const revisions = doc._revs_info;
+      const availableRevs = new Set((revisions || []).filter((e) => e.status === "available").map((e) => e.rev));
+      if (currentRev) {
+        availableRevs.add(currentRev);
+      }
+      for (const rev of availableRevs) {
+        const entry = await this.database.localDatabase.getDBEntry(filename, { rev }, false, true, true);
+        if (entry !== false && await isDocContentSame(readContent(entry), content)) {
+          return true;
+        }
+      }
+    } catch (ex) {
+      this._log(`Could not check revision history for ${filename}`, LOG_LEVEL_VERBOSE);
+      this._log(ex, LOG_LEVEL_VERBOSE);
+    }
+    return false;
+  }
+  async getConflictedRevs(file) {
+    if (!await this.checkIsTargetFile(file)) {
+      return [];
+    }
+    const filename = getDatabasePathFromUXFileInfo(file);
+    const doc = await this.database.localDatabase.getDBEntryMeta(filename, { conflicts: true }, true);
+    if (doc === false) {
+      return [];
+    }
+    return doc._conflicts || [];
+  }
+  async fetch(file, rev, waitForReady, skipCheck = false) {
+    if (skipCheck && !await this.checkIsTargetFile(file)) {
+      return false;
+    }
+    const entry = await this.fetchEntry(file, rev, waitForReady, true);
+    if (entry === false) {
+      return false;
+    }
+    const data = createBlob(readContent(entry));
+    const path = stripAllPrefixes(entry.path);
+    const fileInfo = {
+      name: path.split("/").pop(),
+      path,
+      stat: {
+        size: entry.size,
+        ctime: entry.ctime,
+        mtime: entry.mtime,
+        type: "file"
+      },
+      body: data,
+      deleted: entry.deleted || entry._deleted
+    };
+    if (isInternalMetadata(entry.path)) {
+      fileInfo.isInternal = true;
+    }
+    return fileInfo;
+  }
+  async fetchEntryMeta(file, rev, skipCheck = false) {
+    const dbFileName = getDatabasePathFromUXFileInfo(file);
+    if (skipCheck && !await this.checkIsTargetFile(file)) {
+      return false;
+    }
+    const doc = await this.database.localDatabase.getDBEntryMeta(dbFileName, rev ? { rev } : void 0, true);
+    if (doc === false) {
+      return false;
+    }
+    return doc;
+  }
+  async fetchEntryFromMeta(meta, waitForReady = true, skipCheck = false) {
+    if (skipCheck && !await this.checkIsTargetFile(meta.path)) {
+      return false;
+    }
+    const doc = await this.database.localDatabase.getDBEntryFromMeta(meta, false, waitForReady);
+    if (doc === false) {
+      return false;
+    }
+    return doc;
+  }
+  async fetchEntry(file, rev, waitForReady = true, skipCheck = false) {
+    if (skipCheck && !await this.checkIsTargetFile(file)) {
+      return false;
+    }
+    const entry = await this.fetchEntryMeta(file, rev, true);
+    if (entry === false) {
+      return false;
+    }
+    const doc = await this.fetchEntryFromMeta(entry, waitForReady, true);
+    return doc;
+  }
+  async deleteFromDBbyPath(fullPath, rev) {
+    if (!await this.checkIsTargetFile(fullPath)) {
+      this._log(`deleteFromDBbyPath: File is not target: ${fullPath}`);
+      return true;
+    }
+    const opt = rev ? { rev } : void 0;
+    const ret = await this.database.localDatabase.deleteDBEntry(fullPath, opt);
+    this.events.emitEvent(EVENT_FILE_SAVED);
+    return ret;
+  }
+}
+export {
+  ServiceDatabaseFileAccessBase
+};

package/dist/serviceModules/ServiceFileAccessBase.d.ts

@@ -0,0 +1,64 @@
+import type { FilePath, FilePathWithPrefix, UXDataWriteOptions, UXFileInfo, UXFileInfoStub, UXFolderInfo, UXStat } from "../common/types.js";
+import { ServiceModuleBase } from "./ServiceModuleBase.js";
+import type { APIService } from "../services/base/APIService.js";
+import type { IStorageAccessManager, StorageAccess } from "../interfaces/StorageAccess.js";
+import type { AppLifecycleService } from "../services/base/AppLifecycleService.js";
+import type { FileProcessingService } from "../services/base/FileProcessingService.js";
+import { StorageEventManager } from "../interfaces/StorageEventManager.js";
+import { type CustomRegExp } from "../common/utils.js";
+import type { VaultService } from "../services/base/VaultService.js";
+import type { SettingService } from "../services/base/SettingService.js";
+import type { FileAccessBase, ExtractFile, ExtractFolder } from "./FileAccessBase.js";
+import type { IFileSystemAdapter } from "./adapters/index.js";
+export interface StorageAccessBaseDependencies<TAdapter extends IFileSystemAdapter<any, any, any, any>> {
+    API: APIService;
+    appLifecycle: AppLifecycleService;
+    fileProcessing: FileProcessingService;
+    vault: VaultService;
+    setting: SettingService;
+    storageEventManager: StorageEventManager;
+    storageAccessManager: IStorageAccessManager;
+    vaultAccess: FileAccessBase<TAdapter>;
+}
+export declare class ServiceFileAccessBase<TAdapter extends IFileSystemAdapter<any, any, any, any>> extends ServiceModuleBase<StorageAccessBaseDependencies<TAdapter>> implements StorageAccess {
+    private vaultAccess;
+    private vaultManager;
+    private vault;
+    private setting;
+    constructor(services: StorageAccessBaseDependencies<TAdapter>);
+    restoreState(): Promise<void>;
+    _everyOnFirstInitialize(): Promise<boolean>;
+    _everyCommitPendingFileEvent(): Promise<boolean>;
+    normalisePath(path: string): string;
+    writeFileAuto(path: string, data: string | ArrayBuffer, opt?: UXDataWriteOptions): Promise<boolean>;
+    readFileAuto(path: string): Promise<string | ArrayBuffer>;
+    readFileText(path: string): Promise<string>;
+    isExists(path: string): Promise<boolean>;
+    renameFile(file: UXFileInfoStub | FilePathWithPrefix, newPath: FilePathWithPrefix): Promise<UXFileInfoStub | null>;
+    writeHiddenFileAuto(path: string, data: string | ArrayBuffer, opt?: UXDataWriteOptions): Promise<boolean>;
+    appendHiddenFile(path: string, data: string, opt?: UXDataWriteOptions): Promise<boolean>;
+    stat(path: string): Promise<UXStat | null>;
+    statHidden(path: string): Promise<UXStat | null>;
+    removeHidden(path: string): Promise<boolean>;
+    readHiddenFileAuto(path: string): Promise<string | ArrayBuffer>;
+    readHiddenFileText(path: string): Promise<string>;
+    readHiddenFileBinary(path: string): Promise<ArrayBuffer>;
+    isExistsIncludeHidden(path: string): Promise<boolean>;
+    ensureDir(path: string): Promise<boolean>;
+    _triggerFileEvent(event: string, path: string): Promise<void>;
+    triggerFileEvent(event: string, path: string): void;
+    triggerHiddenFile(path: string): Promise<void>;
+    getFileStub(path: string): Promise<UXFileInfoStub | null>;
+    readStubContent(stub: UXFileInfoStub): Promise<UXFileInfo | false>;
+    getStub(path: string): Promise<UXFileInfoStub | UXFolderInfo | null>;
+    getFiles(): Promise<UXFileInfoStub[]>;
+    getFileNames(): Promise<FilePath[]>;
+    getFilesIncludeHidden(basePath: string, includeFilter?: CustomRegExp[], excludeFilter?: CustomRegExp[], skipFolder?: string[]): Promise<FilePath[]>;
+    touched(file: UXFileInfoStub | FilePathWithPrefix): Promise<void>;
+    recentlyTouched(file: UXFileInfoStub | FilePathWithPrefix): Promise<boolean>;
+    clearTouched(): void;
+    delete(file: FilePathWithPrefix | UXFileInfoStub | string, force: boolean): Promise<void>;
+    trash(file: FilePathWithPrefix | UXFileInfoStub | string, system: boolean): Promise<void>;
+    __deleteVaultItem(file: ExtractFile<TAdapter> | ExtractFolder<TAdapter>): Promise<void>;
+    deleteVaultItem(fileSrc: FilePathWithPrefix | UXFileInfoStub | UXFolderInfo): Promise<void>;
+}

package/dist/serviceModules/ServiceFileAccessBase.js

@@ -0,0 +1,312 @@
+import { LOG_LEVEL_INFO, LOG_LEVEL_VERBOSE } from "octagonal-wheels/common/logger";
+import { ServiceModuleBase } from "./ServiceModuleBase.js";
+import { StorageEventManager } from "../interfaces/StorageEventManager.js";
+import { createBlob, fireAndForget } from "../common/utils.js";
+class ServiceFileAccessBase extends ServiceModuleBase {
+  vaultAccess;
+  vaultManager;
+  vault;
+  setting;
+  constructor(services) {
+    super(services);
+    this.vault = services.vault;
+    this.setting = services.setting;
+    this.vaultManager = services.storageEventManager;
+    this.vaultAccess = services.vaultAccess;
+    services.appLifecycle.onFirstInitialise.addHandler(this._everyOnFirstInitialize.bind(this));
+    services.fileProcessing.commitPendingFileEvents.addHandler(this._everyCommitPendingFileEvent.bind(this));
+  }
+  restoreState() {
+    return this.vaultManager.restoreState();
+  }
+  async _everyOnFirstInitialize() {
+    await this.vaultManager.beginWatch();
+    return Promise.resolve(true);
+  }
+  async _everyCommitPendingFileEvent() {
+    await this.vaultManager.waitForIdle();
+    return Promise.resolve(true);
+  }
+  normalisePath(path) {
+    return this.vaultAccess.normalisePath(path);
+  }
+  async writeFileAuto(path, data, opt) {
+    const file = await this.vaultAccess.getAbstractFileByPath(path);
+    if (this.vaultAccess.isFile(file)) {
+      return this.vaultAccess.vaultModify(file, data, opt);
+    } else if (file === null) {
+      if (!path.endsWith(".md")) {
+        await this.vaultAccess.adapterWrite(path, data, opt);
+        return await this.vaultAccess.adapterExists(path);
+      } else {
+        try {
+          return await this.vaultAccess.vaultCreate(path, data, opt) !== null;
+        } catch (ex) {
+          if (ex instanceof Error && ex.message === "File already exists.") {
+            await this.vaultAccess.adapterWrite(path, data, opt);
+            return await this.vaultAccess.adapterExists(path);
+          }
+          throw ex;
+        }
+      }
+    } else {
+      this._log(`Could not write file (Possibly already exists as a folder): ${path}`, LOG_LEVEL_VERBOSE);
+      return false;
+    }
+  }
+  async readFileAuto(path) {
+    const file = await this.vaultAccess.getAbstractFileByPath(path);
+    if (this.vaultAccess.isFile(file)) {
+      return this.vaultAccess.vaultReadAuto(file);
+    } else {
+      throw new Error(`Could not read file (Possibly does not exist): ${path}`);
+    }
+  }
+  async readFileText(path) {
+    const file = await this.vaultAccess.getAbstractFileByPath(path);
+    if (this.vaultAccess.isFile(file)) {
+      return this.vaultAccess.vaultRead(file);
+    } else {
+      throw new Error(`Could not read file (Possibly does not exist): ${path}`);
+    }
+  }
+  async isExists(path) {
+    return this.vaultAccess.isFile(await this.vaultAccess.getAbstractFileByPath(path));
+  }
+  async renameFile(file, newPath) {
+    const oldPath = typeof file === "string" ? file : file.path;
+    const nativeFile = await this.vaultAccess.getAbstractFileByPath(oldPath);
+    if (!this.vaultAccess.isFile(nativeFile)) {
+      this._log(`Could not rename file (Possibly does not exist): ${oldPath}`, LOG_LEVEL_VERBOSE);
+      return null;
+    }
+    const renamedNativeFile = await this.vaultAccess.vaultRename(nativeFile, newPath);
+    const renamedFile = this.vaultAccess.nativeFileToUXFileInfoStub(renamedNativeFile);
+    await this.touched(renamedFile);
+    return renamedFile;
+  }
+  async writeHiddenFileAuto(path, data, opt) {
+    try {
+      await this.vaultAccess.adapterWrite(path, data, opt);
+      return true;
+    } catch (e) {
+      this._log(`Could not write hidden file: ${path}`, LOG_LEVEL_VERBOSE);
+      this._log(e, LOG_LEVEL_VERBOSE);
+      return false;
+    }
+  }
+  async appendHiddenFile(path, data, opt) {
+    try {
+      await this.vaultAccess.adapterAppend(path, data, opt);
+      return true;
+    } catch (e) {
+      this._log(`Could not append hidden file: ${path}`, LOG_LEVEL_VERBOSE);
+      this._log(e, LOG_LEVEL_VERBOSE);
+      return false;
+    }
+  }
+  async stat(path) {
+    const file = await this.vaultAccess.getAbstractFileByPath(path);
+    if (file === null) return Promise.resolve(null);
+    if (this.vaultAccess.isFile(file)) {
+      const fileWithStat = file;
+      return Promise.resolve({
+        ctime: fileWithStat.stat.ctime,
+        mtime: fileWithStat.stat.mtime,
+        size: fileWithStat.stat.size,
+        type: "file"
+      });
+    } else {
+      throw new Error(`Could not stat file (Possibly does not exist): ${path}`);
+    }
+  }
+  statHidden(path) {
+    return this.vaultAccess.tryAdapterStat(path);
+  }
+  async removeHidden(path) {
+    try {
+      await this.vaultAccess.adapterRemove(path);
+      if (this.vaultAccess.tryAdapterStat(path) !== null) {
+        return false;
+      }
+      return true;
+    } catch (e) {
+      this._log(`Could not remove hidden file: ${path}`, LOG_LEVEL_VERBOSE);
+      this._log(e, LOG_LEVEL_VERBOSE);
+      return false;
+    }
+  }
+  async readHiddenFileAuto(path) {
+    return await this.vaultAccess.adapterReadAuto(path);
+  }
+  async readHiddenFileText(path) {
+    return await this.vaultAccess.adapterRead(path);
+  }
+  async readHiddenFileBinary(path) {
+    return await this.vaultAccess.adapterReadBinary(path);
+  }
+  async isExistsIncludeHidden(path) {
+    return await this.vaultAccess.tryAdapterStat(path) !== null;
+  }
+  async ensureDir(path) {
+    try {
+      await this.vaultAccess.ensureDirectory(path);
+      return true;
+    } catch (e) {
+      this._log(`Could not ensure directory: ${path}`, LOG_LEVEL_VERBOSE);
+      this._log(e, LOG_LEVEL_VERBOSE);
+      return false;
+    }
+  }
+  async _triggerFileEvent(event, path) {
+    const file = await this.vaultAccess.getAbstractFileByPath(path);
+    if (file === null) return;
+    this.vaultAccess.trigger(event, file);
+  }
+  triggerFileEvent(event, path) {
+    fireAndForget(async () => await this._triggerFileEvent(event, path));
+  }
+  async triggerHiddenFile(path) {
+    await this.vaultAccess.reconcileInternalFile(path);
+  }
+  // getFileStub(file: TFile): UXFileInfoStub {
+  //     return  TFileToUXFileInfoStub(file);
+  // }
+  async getFileStub(path) {
+    const file = await this.vaultAccess.getAbstractFileByPath(path);
+    if (this.vaultAccess.isFile(file)) {
+      return this.vaultAccess.nativeFileToUXFileInfoStub(file);
+    } else {
+      return null;
+    }
+  }
+  async readStubContent(stub) {
+    const file = await this.vaultAccess.getAbstractFileByPath(stub.path);
+    if (!this.vaultAccess.isFile(file)) {
+      this._log(`Could not read file (Possibly does not exist or a folder): ${stub.path}`, LOG_LEVEL_VERBOSE);
+      return false;
+    }
+    const data = await this.vaultAccess.vaultReadAuto(file);
+    return {
+      ...stub,
+      ...this.vaultAccess.nativeFileToUXFileInfoStub(file),
+      body: createBlob(data)
+    };
+  }
+  async getStub(path) {
+    const file = await this.vaultAccess.getAbstractFileByPath(path);
+    if (this.vaultAccess.isFile(file)) {
+      return this.vaultAccess.nativeFileToUXFileInfoStub(file);
+    } else if (this.vaultAccess.isFolder(file)) {
+      return this.vaultAccess.nativeFolderToUXFolder(file);
+    }
+    return null;
+  }
+  async getFiles() {
+    const files = await this.vaultAccess.getFiles();
+    return files.map((f) => this.vaultAccess.nativeFileToUXFileInfoStub(f));
+  }
+  async getFileNames() {
+    const files = await this.vaultAccess.getFiles();
+    return files.map((f) => f.path);
+  }
+  async getFilesIncludeHidden(basePath, includeFilter, excludeFilter, skipFolder = [".git", ".trash", "node_modules"]) {
+    let w;
+    try {
+      w = await this.vaultAccess.adapterList(basePath);
+    } catch (ex) {
+      this._log(`Could not traverse(getFilesIncludeHidden):${basePath}`, LOG_LEVEL_INFO);
+      this._log(ex, LOG_LEVEL_VERBOSE);
+      return [];
+    }
+    skipFolder = skipFolder.map((e) => e.toLowerCase());
+    let files = [];
+    for (const file of w.files) {
+      if (includeFilter && includeFilter.length > 0) {
+        if (!includeFilter.some((e) => e.test(file))) continue;
+      }
+      if (excludeFilter && excludeFilter.some((ee) => ee.test(file))) {
+        continue;
+      }
+      if (await this.vault.isIgnoredByIgnoreFile(file)) continue;
+      files.push(file);
+    }
+    for (const v of w.folders) {
+      const folderName = (v.split("/").pop() ?? "").toLowerCase();
+      if (skipFolder.some((e) => folderName === e)) {
+        continue;
+      }
+      if (excludeFilter && excludeFilter.some((e) => e.test(v))) {
+        continue;
+      }
+      if (await this.vault.isIgnoredByIgnoreFile(v)) {
+        continue;
+      }
+      files = files.concat(await this.getFilesIncludeHidden(v, includeFilter, excludeFilter, skipFolder));
+    }
+    return files;
+  }
+  async touched(file) {
+    const path = typeof file === "string" ? file : file.path;
+    await this.vaultAccess.touch(path);
+  }
+  async recentlyTouched(file) {
+    const xFile = typeof file === "string" ? await this.vaultAccess.getAbstractFileByPath(file) : file;
+    if (xFile === null) return false;
+    if (this.vaultAccess.isFolder(xFile)) return false;
+    return this.vaultAccess.recentlyTouched(xFile);
+  }
+  clearTouched() {
+    this.vaultAccess.clearTouched();
+  }
+  async delete(file, force) {
+    const xPath = typeof file === "string" ? file : file.path;
+    const xFile = await this.vaultAccess.getAbstractFileByPath(xPath);
+    if (xFile === null) return Promise.resolve();
+    if (!this.vaultAccess.isFile(xFile) && !this.vaultAccess.isFolder(xFile)) return Promise.resolve();
+    return this.vaultAccess.delete(xFile, force);
+  }
+  async trash(file, system) {
+    const xPath = typeof file === "string" ? file : file.path;
+    const xFile = await this.vaultAccess.getAbstractFileByPath(xPath);
+    if (xFile === null) return Promise.resolve();
+    if (!this.vaultAccess.isFile(xFile) && !this.vaultAccess.isFolder(xFile)) return Promise.resolve();
+    return this.vaultAccess.trash(xFile, system);
+  }
+  async __deleteVaultItem(file) {
+    const filePath = this.vaultAccess.getPath(file);
+    if (this.vaultAccess.isFile(file)) {
+      if (!await this.vault.isTargetFile(filePath)) return;
+    }
+    const dir = file.parent;
+    const settings = this.setting.currentSettings();
+    if (settings.trashInsteadDelete) {
+      await this.vaultAccess.trash(file, false);
+    } else {
+      await this.vaultAccess.delete(file, true);
+    }
+    this._log(`xxx <- STORAGE (deleted) ${filePath}`);
+    if (dir) {
+      this._log(`files: ${dir?.children?.length ?? "unknown"}`);
+      if ((dir?.children?.length ?? 0) === 0) {
+        if (!settings.doNotDeleteFolder) {
+          this._log(
+            `All files under the parent directory (${dir.path}) have been deleted, so delete this one.`
+          );
+          await this.__deleteVaultItem(dir);
+        }
+      }
+    }
+  }
+  async deleteVaultItem(fileSrc) {
+    const path = typeof fileSrc === "string" ? fileSrc : fileSrc.path;
+    const file = await this.vaultAccess.getAbstractFileByPath(path);
+    if (file === null) return;
+    if (this.vaultAccess.isFile(file) || this.vaultAccess.isFolder(file)) {
+      return await this.__deleteVaultItem(file);
+    }
+  }
+}
+export {
+  ServiceFileAccessBase
+};