@vrtmrz/livesync-commonlib 0.1.0-rc.0

package/dist/serviceFeatures/remoteConfig.js

@@ -0,0 +1,247 @@
+import { LOG_LEVEL_NOTICE, LOG_LEVEL_VERBOSE } from "../common/logger.js";
+import { ConnectionStringParser } from "../common/ConnectionString.js";
+import { REMOTE_COUCHDB, REMOTE_MINIO, REMOTE_P2P } from "../common/models/setting.const.js";
+import { createInstanceLogFunction } from "../services/lib/logUtils.js";
+function migrateLegacyRemoteConfigurationsInPlace(settings, log) {
+  const hasText = (value) => typeof value === "string" && value.trim() !== "";
+  if (!settings.remoteConfigurations) {
+    settings.remoteConfigurations = {};
+  }
+  if (Object.keys(settings.remoteConfigurations).length !== 0) {
+    return false;
+  }
+  const hasCouchDB = hasText(settings.couchDB_URI);
+  const hasS3 = hasText(settings.endpoint);
+  const hasP2P = hasText(settings.P2P_roomID);
+  if (!hasCouchDB && !hasS3 && !hasP2P) {
+    return false;
+  }
+  log?.("Migrating existing remote configuration to sls+ format...");
+  const candidates = [
+    { id: "legacy-couchdb", name: "CouchDB Remote", type: "couchdb", enabled: hasCouchDB },
+    { id: "legacy-s3", name: "S3 Remote", type: "s3", enabled: hasS3 },
+    { id: "legacy-p2p", name: "P2P Remote", type: "p2p", enabled: hasP2P }
+  ];
+  for (const candidate of candidates) {
+    if (!candidate.enabled) continue;
+    try {
+      const uri = ConnectionStringParser.serialize({
+        type: candidate.type,
+        settings
+      });
+      settings.remoteConfigurations[candidate.id] = {
+        id: candidate.id,
+        name: candidate.name,
+        uri,
+        isEncrypted: false
+      };
+    } catch (e) {
+      log?.(`Failed to migrate ${candidate.type} configuration!`);
+      log?.(e, LOG_LEVEL_VERBOSE);
+    }
+  }
+  const createdIds = Object.keys(settings.remoteConfigurations);
+  if (createdIds.length === 0) {
+    return false;
+  }
+  const preferredId = settings.remoteType === REMOTE_MINIO ? "legacy-s3" : settings.remoteType === REMOTE_P2P ? "legacy-p2p" : "legacy-couchdb";
+  settings.activeConfigurationId = settings.remoteConfigurations[preferredId] ? preferredId : createdIds[0];
+  return true;
+}
+function createRemoteConfigurationId() {
+  return `remote-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+}
+function migrateP2PActiveRemoteConfigurationIdInPlace(settings) {
+  if ((settings.P2P_ActiveRemoteConfigurationId ?? "").trim() !== "") {
+    return false;
+  }
+  const activeId = settings.activeConfigurationId;
+  if (!activeId) {
+    return false;
+  }
+  const config = settings.remoteConfigurations?.[activeId];
+  if (!config) {
+    return false;
+  }
+  if (settings.remoteType !== REMOTE_P2P) {
+    return false;
+  }
+  try {
+    const parsed = ConnectionStringParser.parse(config.uri);
+    if (parsed.type !== "p2p") {
+      return false;
+    }
+  } catch {
+    return false;
+  }
+  settings.P2P_ActiveRemoteConfigurationId = activeId;
+  return true;
+}
+async function migrateToMultipleRemoteConfigurations(host) {
+  const log = createInstanceLogFunction("SF:RemoteConfig", host.services.API);
+  const settings = host.services.setting.currentSettings();
+  if (migrateLegacyRemoteConfigurationsInPlace(settings, log)) {
+    await host.services.setting.saveSettingData();
+    log(`Successfully migrated ${Object.keys(settings.remoteConfigurations).length} remote configuration(s).`);
+    return true;
+  }
+  return false;
+}
+function activateRemoteConfiguration(settings, id) {
+  const config = settings.remoteConfigurations?.[id];
+  if (!config) return false;
+  settings.activeConfigurationId = id;
+  try {
+    const parsed = ConnectionStringParser.parse(config.uri);
+    if (parsed.type === "couchdb") {
+      settings.remoteType = REMOTE_COUCHDB;
+      Object.assign(settings, parsed.settings);
+    } else if (parsed.type === "s3") {
+      settings.remoteType = REMOTE_MINIO;
+      Object.assign(settings, parsed.settings);
+    } else if (parsed.type === "p2p") {
+      settings.remoteType = REMOTE_P2P;
+      Object.assign(settings, parsed.settings);
+    }
+    return settings;
+  } catch {
+    return false;
+  }
+}
+function activateP2PRemoteConfiguration(settings, id) {
+  const config = settings.remoteConfigurations?.[id];
+  if (!config) return false;
+  try {
+    const parsed = ConnectionStringParser.parse(config.uri);
+    if (parsed.type !== "p2p") {
+      return false;
+    }
+    const currentRemoteType = settings.remoteType;
+    settings.P2P_ActiveRemoteConfigurationId = id;
+    Object.assign(settings, parsed.settings);
+    settings.remoteType = currentRemoteType;
+    return settings;
+  } catch {
+    return false;
+  }
+}
+async function commandSwitchActiveRemote(host) {
+  const settings = host.services.setting.currentSettings();
+  const configs = settings.remoteConfigurations;
+  if (!configs || Object.keys(configs).length === 0) {
+    host.services.API.addLog("No remote configurations found.", LOG_LEVEL_NOTICE, "remote-config");
+    return;
+  }
+  const options = Object.values(configs).map((c) => ({
+    label: `${c.name} (${c.id === settings.activeConfigurationId ? "Active" : "Inactive"})`,
+    value: c.id
+  }));
+  const selectedLabel = await host.services.UI.confirm.askSelectString(
+    "Select a remote configuration to activate",
+    options.map((o) => o.label)
+  );
+  if (selectedLabel) {
+    const actualId = options.find((o) => o.label === selectedLabel)?.value;
+    if (actualId) {
+      let updated = false;
+      await host.services.setting.updateSettings((currentSettings) => {
+        const activated = activateRemoteConfiguration(currentSettings, actualId);
+        if (activated) {
+          updated = true;
+          return activated;
+        }
+        return currentSettings;
+      });
+      if (updated) {
+        host.services.API.addLog(`Switched to remote: ${selectedLabel}`, LOG_LEVEL_NOTICE, "remote-config");
+        await host.services.control.applySettings();
+        await host.services.setting.saveSettingData();
+      }
+    }
+  }
+}
+async function commandReplicateWithSpecificRemote(host) {
+  const settings = host.services.setting.currentSettings();
+  const configs = settings.remoteConfigurations;
+  if (!configs || Object.keys(configs).length === 0) {
+    host.services.API.addLog("No remote configurations found.", LOG_LEVEL_NOTICE, "remote-config");
+    return;
+  }
+  const selectedName = await host.services.UI.confirm.askSelectString(
+    "Select a remote to replicate with",
+    Object.values(configs).map((c) => c.name)
+  );
+  if (selectedName) {
+    const config = Object.values(configs).find((c) => c.name === selectedName);
+    if (config) {
+      try {
+        let updated = false;
+        await host.services.setting.updateSettings((currentSettings) => {
+          const activated = activateRemoteConfiguration(currentSettings, config.id);
+          if (activated) {
+            updated = true;
+            return activated;
+          }
+          return currentSettings;
+        });
+        if (updated) {
+          host.services.API.addLog(
+            `Switched to remote: ${selectedName} and starting replication...`,
+            LOG_LEVEL_NOTICE,
+            "remote-config"
+          );
+          await host.services.control.applySettings();
+          await host.services.setting.saveSettingData();
+          await host.services.replication.replicate(true);
+        }
+      } catch (e) {
+        host.services.API.addLog(
+          `Failed to parse remote! Detailed information is available in verbose logs.`,
+          LOG_LEVEL_NOTICE,
+          "remote-config"
+        );
+        host.services.API.addLog(e, LOG_LEVEL_VERBOSE, "remote-config");
+      }
+    }
+  }
+}
+function useRemoteConfigurationMigration(host) {
+  host.services.appLifecycle.onSettingLoaded.addHandler(async () => {
+    try {
+      await migrateToMultipleRemoteConfigurations(host);
+    } catch (e) {
+      host.services.API.addLog(
+        `Migration failed! Detailed information is available in verbose logs.`,
+        LOG_LEVEL_NOTICE,
+        "remote-config"
+      );
+      host.services.API.addLog(e, LOG_LEVEL_VERBOSE, "remote-config");
+    }
+    return true;
+  });
+}
+function useRemoteConfiguration(host) {
+  host.services.API.addCommand({
+    id: "livesync-switch-remote",
+    name: "Switch Active Remote",
+    callback: () => commandSwitchActiveRemote(host)
+  });
+  host.services.API.addCommand({
+    id: "livesync-replicate-with-specific",
+    name: "Replicate with specific remote",
+    callback: () => commandReplicateWithSpecificRemote(host)
+  });
+  return true;
+}
+export {
+  activateP2PRemoteConfiguration,
+  activateRemoteConfiguration,
+  commandReplicateWithSpecificRemote,
+  commandSwitchActiveRemote,
+  createRemoteConfigurationId,
+  migrateLegacyRemoteConfigurationsInPlace,
+  migrateP2PActiveRemoteConfigurationIdInPlace,
+  migrateToMultipleRemoteConfigurations,
+  useRemoteConfiguration,
+  useRemoteConfigurationMigration
+};

package/dist/serviceFeatures/setupObsidian/qrCode.d.ts

@@ -0,0 +1,4 @@
+import type { NecessaryServices } from "../../interfaces/ServiceModule.js";
+import type { SetupFeatureHost } from "./types.js";
+export declare function encodeSetupSettingsAsQR(host: SetupFeatureHost): Promise<string>;
+export declare function useSetupQRCodeFeature(host: NecessaryServices<"API" | "UI" | "setting" | "appLifecycle", never>): void;

package/dist/serviceFeatures/setupObsidian/qrCode.js

@@ -0,0 +1,67 @@
+import { encodeQR, encodeSettingsToQRCodeData, OutputFormat } from "../../API/processSetting.js";
+import { EVENT_REQUEST_SHOW_SETUP_QR } from "../../events/coreEvents.js";
+import { fireAndForget } from "../../common/utils.js";
+async function encodeSetupSettingsAsQR(host) {
+  const settingString = encodeSettingsToQRCodeData(host.services.setting.currentSettings());
+  const result = encodeQR(settingString, OutputFormat.SVG);
+  if (result === "") {
+    return "";
+  }
+  if (typeof result === "string") {
+    const msg = host.services.context.translate("Setup.QRCode", { qr_image: result });
+    await host.services.UI.confirm.confirmWithMessage("Settings QR Code", msg, ["OK"], "OK");
+    return result;
+  } else {
+    let currentIndex = 0;
+    while (currentIndex < result.total) {
+      const msg = `The setting is too large for a single QR code.
+We are using the aggregator to combine multiple QR codes.
+Your settings will not be sent to any server; they will be processed only on your device.
+Please scan this QR code with your mobile's camera, and open the page in your browser.
+After all parts are collected, the page will navigate you back to Obsidian with the aggregated settings.
+
+Progress: ${currentIndex + 1} / ${result.total}
+${result.parts[currentIndex]}`;
+      const buttons = [];
+      if (currentIndex > 0) buttons.push("Back");
+      if (currentIndex < result.total - 1) {
+        buttons.push("Next");
+        buttons.push("Cancel");
+      } else {
+        buttons.push("Done");
+      }
+      const choice = await host.services.UI.confirm.confirmWithMessage(
+        "Settings QR Code (Aggregated)",
+        msg,
+        buttons,
+        buttons[buttons.indexOf("Next") !== -1 ? buttons.indexOf("Next") : buttons.indexOf("Done")]
+      );
+      if (choice === "Next") {
+        currentIndex++;
+      } else if (choice === "Back") {
+        currentIndex--;
+      } else {
+        break;
+      }
+    }
+    return result.parts[0];
+  }
+}
+function useSetupQRCodeFeature(host) {
+  host.services.appLifecycle.onLoaded.addHandler(() => {
+    host.services.API.addCommand({
+      id: "livesync-setting-qr",
+      name: "Show settings as a QR code",
+      callback: () => fireAndForget(encodeSetupSettingsAsQR(host))
+    });
+    host.services.context.events.onEvent(
+      EVENT_REQUEST_SHOW_SETUP_QR,
+      () => fireAndForget(() => encodeSetupSettingsAsQR(host))
+    );
+    return Promise.resolve(true);
+  });
+}
+export {
+  encodeSetupSettingsAsQR,
+  useSetupQRCodeFeature
+};

package/dist/serviceFeatures/setupObsidian/setupUri.d.ts

@@ -0,0 +1,7 @@
+import type { LogFunction } from "../../services/lib/logUtils.js";
+import type { NecessaryServices } from "../../interfaces/ServiceModule.js";
+import type { SetupFeatureHost } from "./types.js";
+export declare function askEncryptingPassphrase(host: SetupFeatureHost): Promise<string | false>;
+export declare function copySetupURI(host: SetupFeatureHost, log: LogFunction, stripExtra?: boolean): Promise<void>;
+export declare function copySetupURIFull(host: SetupFeatureHost, log: LogFunction): Promise<void>;
+export declare function useSetupURIFeature(host: NecessaryServices<"API" | "UI" | "setting" | "appLifecycle", never>): void;

package/dist/serviceFeatures/setupObsidian/setupUri.js

@@ -0,0 +1,70 @@
+import { LOG_LEVEL_NOTICE } from "../../common/types.js";
+import { createInstanceLogFunction } from "../../services/lib/logUtils.js";
+import { encodeSettingsToSetupURI } from "../../API/processSetting.js";
+import { EVENT_REQUEST_COPY_SETUP_URI } from "../../events/coreEvents.js";
+import { fireAndForget } from "../../common/utils.js";
+async function askEncryptingPassphrase(host) {
+  return await host.services.UI.confirm.askString(
+    "Encrypt your settings",
+    "The passphrase to encrypt the setup URI",
+    "",
+    true
+  );
+}
+async function copySetupURI(host, log, stripExtra = true) {
+  const encryptingPassphrase = await askEncryptingPassphrase(host);
+  if (encryptingPassphrase === false) return;
+  const encryptedURI = await encodeSettingsToSetupURI(
+    host.services.setting.currentSettings(),
+    encryptingPassphrase,
+    [...stripExtra ? ["pluginSyncExtendedSetting"] : []],
+    true
+  );
+  if (await host.services.UI.promptCopyToClipboard("Setup URI", encryptedURI)) {
+    log("Setup URI copied to clipboard", LOG_LEVEL_NOTICE);
+  }
+}
+async function copySetupURIFull(host, log) {
+  const encryptingPassphrase = await askEncryptingPassphrase(host);
+  if (encryptingPassphrase === false) return;
+  const encryptedURI = await encodeSettingsToSetupURI(
+    host.services.setting.currentSettings(),
+    encryptingPassphrase,
+    [],
+    false
+  );
+  if (await host.services.UI.promptCopyToClipboard("Setup URI", encryptedURI)) {
+    log("Setup URI copied to clipboard", LOG_LEVEL_NOTICE);
+  }
+}
+function useSetupURIFeature(host) {
+  const log = createInstanceLogFunction("SF:SetupURI", host.services.API);
+  host.services.appLifecycle.onLoaded.addHandler(() => {
+    host.services.API.addCommand({
+      id: "livesync-copysetupuri",
+      name: "Copy settings as a new setup URI",
+      callback: () => fireAndForget(copySetupURI(host, log))
+    });
+    host.services.API.addCommand({
+      id: "livesync-copysetupuri-short",
+      name: "Copy settings as a new setup URI (With customization sync)",
+      callback: () => fireAndForget(copySetupURI(host, log, false))
+    });
+    host.services.API.addCommand({
+      id: "livesync-copysetupurifull",
+      name: "Copy settings as a new setup URI (Full)",
+      callback: () => fireAndForget(copySetupURIFull(host, log))
+    });
+    host.services.context.events.onEvent(
+      EVENT_REQUEST_COPY_SETUP_URI,
+      () => fireAndForget(() => copySetupURI(host, log))
+    );
+    return Promise.resolve(true);
+  });
+}
+export {
+  askEncryptingPassphrase,
+  copySetupURI,
+  copySetupURIFull,
+  useSetupURIFeature
+};

package/dist/serviceFeatures/setupObsidian/types.d.ts

@@ -0,0 +1,2 @@
+import type { NecessaryServices } from "../../interfaces/ServiceModule.js";
+export type SetupFeatureHost = NecessaryServices<"API" | "UI" | "setting", never>;

package/dist/serviceFeatures/targetFilter.d.ts

@@ -0,0 +1,24 @@
+import { type UXFileInfoStub } from "../common/types.js";
+import { type LogFunction } from "../services/lib/logUtils.js";
+import type { NecessaryServices } from "../interfaces/ServiceModule.js";
+/**
+ * This is a simple handler that accepts all files.
+ */
+export declare function isAcceptedAlwaysFactory(host: NecessaryServices<never, never>, log: LogFunction): (file: string | UXFileInfoStub) => Promise<boolean>;
+/**
+ * Check if a file is accepted based on filename duplication in the vault.
+ */
+export declare function isAcceptedInFilenameDuplicationFactory(host: NecessaryServices<"vault" | "fileProcessing", "storageAccess">, log: LogFunction): (file: string | UXFileInfoStub) => Promise<boolean>;
+/**
+ * Check if a file is accepted by the local database (e.g., not rejected by the local DB's target file check).
+ * Local database responsible for non-internal files, syncOnlyRegEx, syncIgnoreRegEx
+ * This possibly should be separated.
+ */
+export declare function isAcceptedByLocalDBFactory(host: NecessaryServices<"database" | "databaseEvents", never>, log: LogFunction): (file: string | UXFileInfoStub) => Promise<boolean>;
+/**
+ * Factory function to create the isAcceptedByIgnoreFiles handler.
+ * This handler checks if a file is ignored based on the ignore files specified in the settings.
+ * It also caches the ignore file contents for performance and listens to settings changes to invalidate the cache.
+ */
+export declare function isAcceptedByIgnoreFilesFactory(host: NecessaryServices<"setting" | "appLifecycle", "storageAccess">, log: LogFunction): (file: string | UXFileInfoStub) => Promise<boolean>;
+export declare function useTargetFilters(host: NecessaryServices<"API" | "vault" | "fileProcessing" | "setting" | "appLifecycle" | "database" | "databaseEvents", "storageAccess">): void;

package/dist/serviceFeatures/targetFilter.js

@@ -0,0 +1,178 @@
+import { LOG_LEVEL_DEBUG, LOG_LEVEL_VERBOSE } from "../common/types.js";
+import { createInstanceLogFunction } from "../services/lib/logUtils.js";
+import { getStoragePathFromUXFileInfo } from "../common/typeUtils.js";
+import { isAcceptedAll } from "../string_and_binary/path.js";
+import { Computed } from "octagonal-wheels/dataobject/Computed";
+import { promiseWithResolvers } from "octagonal-wheels/promises";
+function isAcceptedAlwaysFactory(host, log) {
+  return (file) => {
+    log("File is target finally: " + getStoragePathFromUXFileInfo(file), LOG_LEVEL_DEBUG);
+    return Promise.resolve(true);
+  };
+}
+function isAcceptedInFilenameDuplicationFactory(host, log) {
+  const fileCountMapComputed = new Computed({
+    evaluation: async (fileEventCount) => {
+      const vaultFiles = (await host.serviceModules.storageAccess.getFileNames()).sort();
+      const fileCountMap = {};
+      for (const file of vaultFiles) {
+        const lc = file.toLowerCase();
+        if (!fileCountMap[lc]) {
+          fileCountMap[lc] = 1;
+        } else {
+          fileCountMap[lc]++;
+        }
+      }
+      return fileCountMap;
+    },
+    requiresUpdate: (args, previousArgs, previousResult) => {
+      if (!previousResult) return true;
+      if (previousResult instanceof Error) return true;
+      if (!previousArgs) return true;
+      if (args[0] === previousArgs[0]) {
+        return false;
+      }
+      return true;
+    }
+  });
+  return async function isAcceptedInFilenameDuplication(file) {
+    const fileCountMap = (await fileCountMapComputed.update(host.services.fileProcessing.totalStorageFileEventCount)).value;
+    const filepath = getStoragePathFromUXFileInfo(file);
+    const lc = filepath.toLowerCase();
+    if (host.services.vault.shouldCheckCaseInsensitively()) {
+      if (lc in fileCountMap && fileCountMap[lc] > 1) {
+        log("File is duplicated (case-insensitive): " + filepath);
+        return false;
+      }
+    }
+    log("File is not duplicated: " + filepath, LOG_LEVEL_DEBUG);
+    return true;
+  };
+}
+function isAcceptedByLocalDBFactory(host, log) {
+  const database = host.services.database;
+  const databaseEvents = host.services.databaseEvents;
+  let isReady = promiseWithResolvers();
+  databaseEvents.onDatabaseHasReady.addHandler(() => {
+    isReady.resolve();
+    return Promise.resolve(true);
+  });
+  databaseEvents.onUnloadDatabase.addHandler(() => {
+    isReady = promiseWithResolvers();
+    return Promise.resolve(true);
+  });
+  return async (file) => {
+    await isReady.promise;
+    const filepath = getStoragePathFromUXFileInfo(file);
+    if (!await Promise.resolve(database.localDatabase.isTargetFile(filepath))) {
+      log("File is not target by local DB: " + filepath);
+      return false;
+    }
+    log("File is target by local DB: " + filepath, LOG_LEVEL_DEBUG);
+    return true;
+  };
+}
+function isAcceptedByIgnoreFilesFactory(host, log) {
+  let ignoreFiles = [];
+  const ignoreFileCacheMap = /* @__PURE__ */ new Map();
+  const refreshSettings = () => {
+    const settings = host.services.setting.currentSettings();
+    ignoreFiles = settings?.ignoreFiles.split(",").map((e) => e.trim()) || [];
+    return Promise.resolve(true);
+  };
+  const invalidateIgnoreFileCache = (path) => {
+    const key = path.toLowerCase();
+    ignoreFileCacheMap.delete(key);
+  };
+  const getIgnoreFile = async (path) => {
+    const key = path.toLowerCase();
+    const cached = ignoreFileCacheMap.get(key);
+    if (cached !== void 0) {
+      return cached;
+    }
+    try {
+      if (!await host.serviceModules.storageAccess.isExistsIncludeHidden(path)) {
+        log(`[ignore] Ignore file does not exist: ${path}`, LOG_LEVEL_DEBUG);
+        ignoreFileCacheMap.set(key, false);
+        return false;
+      }
+      const file = await host.serviceModules.storageAccess.readHiddenFileText(path);
+      const gitignore = file.split(/\r?\n/g).map((e) => e.replace(/\r$/, "")).map((e) => e.trim());
+      ignoreFileCacheMap.set(key, gitignore);
+      log(`[ignore] Ignore file loaded: ${path}`, LOG_LEVEL_VERBOSE);
+      return gitignore;
+    } catch (ex) {
+      log(`[ignore] Failed to read ignore file ${path}`);
+      log(ex, LOG_LEVEL_VERBOSE);
+      ignoreFileCacheMap.set(key, void 0);
+      return false;
+    }
+  };
+  host.services.setting.onSettingRealised.addHandler(refreshSettings);
+  host.services.appLifecycle.onLoaded.addHandler(refreshSettings);
+  void refreshSettings();
+  return async function isAcceptedByIgnoreFiles(file) {
+    const settings = host.services.setting.currentSettings();
+    if (!settings.useIgnoreFiles) {
+      return true;
+    }
+    const filepath = getStoragePathFromUXFileInfo(file);
+    invalidateIgnoreFileCache(filepath);
+    log("Checking ignore files for: " + filepath, LOG_LEVEL_DEBUG);
+    if (!await isAcceptedAll(filepath, ignoreFiles, (filename) => getIgnoreFile(filename))) {
+      log("File is ignored by ignore files: " + filepath);
+      return false;
+    }
+    log("File is not ignored by ignore files: " + filepath, LOG_LEVEL_DEBUG);
+    return true;
+  };
+}
+function useTargetFilters(host) {
+  const logger = createInstanceLogFunction("SFTargetFilter", host.services.API);
+  const services = host.services;
+  const serviceModules = host.serviceModules;
+  const _isAcceptedFilenameDuplication = isAcceptedInFilenameDuplicationFactory(
+    {
+      services: { context: services.context, vault: services.vault, fileProcessing: services.fileProcessing },
+      serviceModules: { storageAccess: serviceModules.storageAccess }
+    },
+    logger
+  );
+  const _isAcceptedByIgnoreFiles = isAcceptedByIgnoreFilesFactory(
+    {
+      services: { context: services.context, setting: services.setting, appLifecycle: services.appLifecycle },
+      serviceModules: { storageAccess: serviceModules.storageAccess }
+    },
+    logger
+  );
+  const _isAcceptedByLocalDB = isAcceptedByLocalDBFactory(
+    {
+      services: { context: services.context, database: services.database, databaseEvents: services.databaseEvents },
+      serviceModules: {}
+    },
+    logger
+  );
+  const _isAcceptedAlways = isAcceptedAlwaysFactory(
+    {
+      services: { context: services.context },
+      serviceModules: {}
+    },
+    logger
+  );
+  services.vault.isTargetFile.addHandler(_isAcceptedFilenameDuplication, 10);
+  services.vault.isTargetFile.addHandler(_isAcceptedByIgnoreFiles, 20);
+  services.vault.isTargetFile.addHandler(_isAcceptedByLocalDB, 30);
+  services.vault.isTargetFile.addHandler(_isAcceptedAlways, 100);
+  const isTargetIgnored = async (file) => {
+    const result = await _isAcceptedByIgnoreFiles(file);
+    return !result;
+  };
+  services.vault.isIgnoredByIgnoreFile.addHandler(isTargetIgnored);
+}
+export {
+  isAcceptedAlwaysFactory,
+  isAcceptedByIgnoreFilesFactory,
+  isAcceptedByLocalDBFactory,
+  isAcceptedInFilenameDuplicationFactory,
+  useTargetFilters
+};