@vrtmrz/livesync-commonlib 0.1.0-rc.0

package/dist/API/processSetting.d.ts

@@ -0,0 +1,41 @@
+import { type ObsidianLiveSyncSettings } from "../common/types.js";
+/**
+ * Encode settings to a tiny array to encode in QRCode,
+ * Due to size limitation of QR code, we encode settings as an array instead of object.
+ * @param settings settings to encode
+ */
+export declare function encodeSettingsToQRCodeData(settings: ObsidianLiveSyncSettings): string;
+/**
+ * Decode settings from QR code data string
+ * @param qr data string from QR code
+ * @returns Decoded settings
+ */
+export declare function decodeSettingsFromQRCodeData(qr: string): ObsidianLiveSyncSettings;
+export declare enum OutputFormat {
+    SVG = 0,
+    ASCII = 1
+}
+export interface SplitQRCodeData {
+    total: number;
+    parts: string[];
+}
+/**
+ * Encode setting string to QR code in specified format
+ * @param settingString Setting string to encode
+ * @param format Output format
+ */
+export declare function encodeQR(settingString: string, format: OutputFormat): string | SplitQRCodeData;
+type ErasureProperties = keyof ObsidianLiveSyncSettings;
+/**
+ * Generate setup URI with encrypted settings
+ * @param settingString Settings to encode
+ * @param passphrase Passphrase to encrypt the settings
+ * @param removeProperties Properties to remove from the settings
+ * Means these properties will not be included in the generated setup URI,
+ * See also necessaryErasureProperties for properties that will always be removed.
+ * @param skipDefaultValue Whether to skip default values
+ * @returns Generated setup URI
+ */
+export declare function encodeSettingsToSetupURI(settingString: ObsidianLiveSyncSettings, passphrase: string, removeProperties?: ErasureProperties[], skipDefaultValue?: boolean): Promise<string>;
+export declare function decodeSettingsFromSetupURI(uri: string, passphrase: string): Promise<false | ObsidianLiveSyncSettings>;
+export {};

package/dist/API/processSetting.js

@@ -0,0 +1,140 @@
+import qrcode from "qrcode-generator";
+import { configURIBase, configURIBaseQR } from "../common/types.js";
+import { decodeAnyArray, encodeAnyArray } from "octagonal-wheels/object";
+import {
+  DEFAULT_SETTINGS,
+  KeyIndexOfSettings,
+  LOG_LEVEL_NOTICE
+} from "../common/types.js";
+import { decryptString, encryptString } from "../encryption/stringEncryption.js";
+import { LOG_LEVEL_VERBOSE, Logger } from "octagonal-wheels/common/logger";
+function encodeSettingsToQRCodeData(settings) {
+  const fullIndexes = Object.entries(KeyIndexOfSettings);
+  let maxIndex = 0;
+  for (const [, index] of fullIndexes) {
+    if (index >= 0 && index > maxIndex) {
+      maxIndex = index;
+    }
+  }
+  const settingArr = new Array(maxIndex + 1).fill(void 0);
+  for (const [settingKey, index] of fullIndexes) {
+    const settingValue = settings[settingKey];
+    if (index < 0) {
+      continue;
+    }
+    settingArr[index] = settingValue;
+  }
+  return encodeAnyArray(settingArr);
+}
+function decodeSettingsFromQRCodeData(qr) {
+  const settingArr = decodeAnyArray(qr);
+  const fullIndexes = Object.entries(KeyIndexOfSettings);
+  const newSettings = { ...DEFAULT_SETTINGS };
+  const skippedSettings = [];
+  for (const [settingKey, index] of fullIndexes) {
+    if (index < 0) {
+      continue;
+    }
+    if (index >= settingArr.length) {
+      skippedSettings.push(`${settingKey} (index ${index})`);
+      continue;
+    }
+    const settingValue = settingArr[index];
+    newSettings[settingKey] = settingValue;
+  }
+  if (skippedSettings.length > 0) {
+    Logger(
+      `Warning: ${skippedSettings.length} settings were skipped during QR decode (array length: ${settingArr.length}): ${skippedSettings.slice(0, 5).join(", ")}${skippedSettings.length > 5 ? "..." : ""}`,
+      LOG_LEVEL_VERBOSE
+    );
+  }
+  return newSettings;
+}
+var OutputFormat = /* @__PURE__ */ ((OutputFormat2) => {
+  OutputFormat2[OutputFormat2["SVG"] = 0] = "SVG";
+  OutputFormat2[OutputFormat2["ASCII"] = 1] = "ASCII";
+  return OutputFormat2;
+})(OutputFormat || {});
+const AGGREGATOR_URL = "https://vrtmrz.github.io/obsidian-livesync/aggregator.html";
+function encodeQR(settingString, format) {
+  const tryEncode = (data) => {
+    const qr = qrcode(0, "L");
+    qr.addData(data);
+    qr.make();
+    if (format === 0 /* SVG */) {
+      return qr.createSvgTag(3);
+    } else if (format === 1 /* ASCII */) {
+      return qr.createASCII(3);
+    }
+    return "";
+  };
+  const uri = `${configURIBaseQR}${encodeURIComponent(settingString)}`;
+  try {
+    return tryEncode(uri);
+  } catch (ex) {
+    Logger(`QR Code size exceeded, switching to aggregator mode`, LOG_LEVEL_NOTICE);
+    Logger(ex, LOG_LEVEL_VERBOSE);
+    const id = Math.random().toString(36).substring(2, 10);
+    const data = encodeURIComponent(settingString);
+    const chunkSize = 2e3;
+    const total = Math.ceil(data.length / chunkSize);
+    const parts = [];
+    for (let i = 0; i < total; i++) {
+      const chunk = data.substring(i * chunkSize, (i + 1) * chunkSize);
+      const partUri = `${AGGREGATOR_URL}#id=${id}&n=${total}&i=${i}&d=${chunk}`;
+      try {
+        parts.push(tryEncode(partUri));
+      } catch (ex2) {
+        Logger(`Failed to encode split QR Code (${ex2?.message || String(ex2)})`, LOG_LEVEL_NOTICE);
+        return "";
+      }
+    }
+    return { total, parts };
+  }
+}
+const necessaryErasureProperties = [
+  "configPassphraseStore",
+  "encryptedCouchDBConnection",
+  "encryptedPassphrase"
+];
+async function encodeSettingsToSetupURI(settingString, passphrase, removeProperties = ["pluginSyncExtendedSetting"], skipDefaultValue = false) {
+  const setting = {
+    ...settingString
+  };
+  if (skipDefaultValue) {
+    const keys = Object.keys(setting);
+    for (const k of keys) {
+      if (JSON.stringify(k in setting ? setting[k] : "") == JSON.stringify(k in DEFAULT_SETTINGS ? DEFAULT_SETTINGS[k] : "*")) {
+        delete setting[k];
+      }
+    }
+  }
+  for (const prop of [...removeProperties]) {
+    delete setting[prop];
+  }
+  for (const prop of necessaryErasureProperties) {
+    setting[prop] = "";
+  }
+  const encryptedSetting = encodeURIComponent(await encryptString(JSON.stringify(setting), passphrase));
+  const uri = `${configURIBase}${encryptedSetting} `;
+  return uri;
+}
+async function decodeSettingsFromSetupURI(uri, passphrase) {
+  const encryptedSetting = uri.substring(configURIBase.length);
+  const decrypted = await decryptString(decodeURIComponent(encryptedSetting), passphrase);
+  try {
+    return JSON.parse(decrypted);
+  } catch (e) {
+    Logger(`Failed to parse settings from decrypted data`, LOG_LEVEL_NOTICE);
+    Logger(e, LOG_LEVEL_VERBOSE);
+    return false;
+  }
+}
+export {
+  OutputFormat,
+  decodeSettingsFromQRCodeData,
+  decodeSettingsFromSetupURI,
+  encodeQR,
+  encodeSettingsToQRCodeData,
+  encodeSettingsToSetupURI
+};

package/dist/ContentSplitter/ContentSplitter.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Content-Splitter for Self-hosted LiveSync.
+ * Splits content into manageable chunks for efficient storage and synchronisation.
+ */
+import { type FilePathWithPrefix } from "../common/types.js";
+import type { ISettingService } from "../services/base/IService.js";
+/**
+ * ContentSplitter interface for splitting content into chunks.
+ */
+export type SplitOptions = {
+    blob: Blob;
+    path: FilePathWithPrefix;
+    pieceSize: number;
+    plainSplit: boolean;
+    minimumChunkSize: number;
+    useWorker: boolean;
+    useSegmenter: boolean;
+};
+/**
+ * The maximum size, in bytes, of a document to be processed by the content splitter in the foreground.
+ */
+export declare const MAX_CHUNKS_SIZE_ON_UI = 1024;
+/**
+ * Options for the content splitter.
+ */
+export type ContentSplitterOptions = {
+    settingService: ISettingService;
+};

package/dist/ContentSplitter/ContentSplitter.js

@@ -0,0 +1,5 @@
+import {} from "../common/types.js";
+const MAX_CHUNKS_SIZE_ON_UI = 1024;
+export {
+  MAX_CHUNKS_SIZE_ON_UI
+};

package/dist/ContentSplitter/ContentSplitterBase.d.ts

@@ -0,0 +1,51 @@
+import { type SavingEntry } from "../common/types.js";
+import { type ContentSplitterOptions, type SplitOptions } from "./ContentSplitter.js";
+export declare abstract class ContentSplitterCore {
+    /**
+     * Options for the content splitter.
+     * These settings include the chunk splitter version and other configurations.
+     */
+    options: ContentSplitterOptions;
+    /**
+     * Task for initialising the content splitter.
+     * This ensures that the splitter is initialised before any operations are performed.
+     */
+    initialised: Promise<boolean> | undefined;
+    /**
+     * Constructor for the content splitter core.
+     * @param params Content splitter options
+     */
+    constructor(params: ContentSplitterOptions);
+    /**
+     * Initialise the content splitter with the provided options.
+     * @param options Content splitter options
+     */
+    abstract initialise(options: ContentSplitterOptions): Promise<boolean>;
+    /**
+     * Split the content of the loaded entry into chunks.
+     * @param entry The loaded entry to be split into chunks
+     */
+    abstract splitContent(entry: SavingEntry): Promise<AsyncGenerator<string, void, unknown> | Generator<string, void, unknown>>;
+}
+export declare abstract class ContentSplitterBase extends ContentSplitterCore {
+    initialise(_options: ContentSplitterOptions): Promise<boolean>;
+    /**
+     * Check whether the content splitter is available for the given settings.
+     * @param setting Content splitter options
+     * @returns True if the content splitter is available; false otherwise
+     */
+    static isAvailableFor(setting: ContentSplitterOptions): boolean;
+    /**
+     * Process the content and split it into chunks.
+     * @param options Blob content to be split into chunks
+     */
+    abstract processSplit(options: SplitOptions): Promise<AsyncGenerator<string, void, unknown> | Generator<string, void, unknown>>;
+    getParamsFor(entry: SavingEntry): SplitOptions;
+    /**
+     * Split the content of the loaded entry into chunks.
+     * This method waits for the initialisation task to complete before proceeding.
+     * @param entry The loaded entry to be split into chunks
+     * @returns A generator that yields the split chunks
+     */
+    splitContent(entry: SavingEntry): Promise<AsyncGenerator<string, void, unknown> | Generator<string, void, unknown>>;
+}

package/dist/ContentSplitter/ContentSplitterBase.js

@@ -0,0 +1,83 @@
+import { MAX_DOC_SIZE_BIN, ChunkAlgorithms } from "../common/types.js";
+import { createTextBlob } from "../common/utils.js";
+import { shouldSplitAsPlainText } from "../string_and_binary/path.js";
+import { MAX_CHUNKS_SIZE_ON_UI } from "./ContentSplitter.js";
+class ContentSplitterCore {
+  /**
+   * Options for the content splitter.
+   * These settings include the chunk splitter version and other configurations.
+   */
+  options;
+  /**
+   * Task for initialising the content splitter.
+   * This ensures that the splitter is initialised before any operations are performed.
+   */
+  initialised;
+  /**
+   * Constructor for the content splitter core.
+   * @param params Content splitter options
+   */
+  constructor(params) {
+    this.options = params;
+    this.initialised = this.initialise(params);
+  }
+}
+class ContentSplitterBase extends ContentSplitterCore {
+  initialise(_options) {
+    this.options = _options;
+    return Promise.resolve(true);
+  }
+  /**
+   * Check whether the content splitter is available for the given settings.
+   * @param setting Content splitter options
+   * @returns True if the content splitter is available; false otherwise
+   */
+  static isAvailableFor(setting) {
+    return false;
+  }
+  getParamsFor(entry) {
+    const settings = this.options.settingService.currentSettings();
+    const maxChunkSize = Math.floor(MAX_DOC_SIZE_BIN * ((settings.customChunkSize || 0) * 1 + 1));
+    const pieceSize = maxChunkSize;
+    const minimumChunkSize = settings.minimumChunkSize;
+    const path = entry.path;
+    const plainSplit = shouldSplitAsPlainText(path);
+    const maxSize = MAX_CHUNKS_SIZE_ON_UI;
+    const blob = entry.data instanceof Blob ? entry.data : createTextBlob(entry.data);
+    let useWorker = true;
+    if (settings.disableWorkerForGeneratingChunks) {
+      useWorker = false;
+    }
+    if (useWorker && settings.processSmallFilesInUIThread) {
+      if (blob.size <= maxSize) {
+        useWorker = false;
+      }
+    }
+    const useSegmenter = settings.chunkSplitterVersion === ChunkAlgorithms.V2Segmenter;
+    return {
+      blob,
+      path,
+      pieceSize,
+      plainSplit,
+      minimumChunkSize,
+      useWorker,
+      useSegmenter
+    };
+  }
+  /**
+   * Split the content of the loaded entry into chunks.
+   * This method waits for the initialisation task to complete before proceeding.
+   * @param entry The loaded entry to be split into chunks
+   * @returns A generator that yields the split chunks
+   */
+  async splitContent(entry) {
+    await this.initialised;
+    const options = this.getParamsFor(entry);
+    const generator = await this.processSplit(options);
+    return generator;
+  }
+}
+export {
+  ContentSplitterBase,
+  ContentSplitterCore
+};

package/dist/ContentSplitter/ContentSplitterRabinKarp.d.ts

@@ -0,0 +1,9 @@
+import type { ContentSplitterOptions, SplitOptions } from "./ContentSplitter.js";
+import { ContentSplitterBase } from "./ContentSplitterBase.js";
+/**
+ * Rabin-Karp content splitter for efficient chunking
+ */
+export declare class ContentSplitterRabinKarp extends ContentSplitterBase {
+    static isAvailableFor(setting: ContentSplitterOptions): boolean;
+    processSplit(options: SplitOptions): Promise<AsyncGenerator<string, void, unknown> | Generator<string, void, unknown>>;
+}

package/dist/ContentSplitter/ContentSplitterRabinKarp.js

@@ -0,0 +1,32 @@
+import { ChunkAlgorithms } from "../common/types.js";
+import { splitPiecesRabinKarp } from "../string_and_binary/chunks.js";
+import { splitPieces2WorkerRabinKarp } from "#worker";
+import { ContentSplitterBase } from "./ContentSplitterBase.js";
+class ContentSplitterRabinKarp extends ContentSplitterBase {
+  static isAvailableFor(setting) {
+    const settings = setting.settingService.currentSettings();
+    return settings.chunkSplitterVersion === ChunkAlgorithms.RabinKarp;
+  }
+  async processSplit(options) {
+    if (options.useWorker) {
+      return (await splitPieces2WorkerRabinKarp(
+        options.blob,
+        options.pieceSize,
+        options.plainSplit,
+        options.minimumChunkSize,
+        options.path
+      ))();
+    } else {
+      return (await splitPiecesRabinKarp(
+        options.blob,
+        options.pieceSize,
+        options.plainSplit,
+        options.minimumChunkSize,
+        options.path
+      ))();
+    }
+  }
+}
+export {
+  ContentSplitterRabinKarp
+};

package/dist/ContentSplitter/ContentSplitterV1.d.ts

@@ -0,0 +1,9 @@
+import type { ContentSplitterOptions, SplitOptions } from "./ContentSplitter.js";
+import { ContentSplitterBase } from "./ContentSplitterBase.js";
+/**
+ * Legacy content splitter for version 1.
+ */
+export declare class ContentSplitterV1 extends ContentSplitterBase {
+    static isAvailableFor(setting: ContentSplitterOptions): boolean;
+    processSplit(options: SplitOptions): Promise<AsyncGenerator<string, void, unknown> | Generator<string, void, unknown>>;
+}

package/dist/ContentSplitter/ContentSplitterV1.js

@@ -0,0 +1,34 @@
+import { ChunkAlgorithms } from "../common/types.js";
+import { splitPieces2 } from "../string_and_binary/chunks.js";
+import { splitPieces2Worker } from "#worker";
+import { ContentSplitterBase } from "./ContentSplitterBase.js";
+class ContentSplitterV1 extends ContentSplitterBase {
+  static isAvailableFor(setting) {
+    const settings = setting.settingService.currentSettings();
+    return settings.chunkSplitterVersion === ChunkAlgorithms.V1 || settings.chunkSplitterVersion === "" || settings.chunkSplitterVersion === void 0;
+  }
+  async processSplit(options) {
+    if (options.useWorker) {
+      return (await splitPieces2Worker(
+        options.blob,
+        options.pieceSize,
+        options.plainSplit,
+        options.minimumChunkSize,
+        options.path,
+        options.useSegmenter
+      ))();
+    } else {
+      return (await splitPieces2(
+        options.blob,
+        options.pieceSize,
+        options.plainSplit,
+        options.minimumChunkSize,
+        options.path,
+        options.useSegmenter
+      ))();
+    }
+  }
+}
+export {
+  ContentSplitterV1
+};

package/dist/ContentSplitter/ContentSplitterV2.d.ts

@@ -0,0 +1,9 @@
+import type { ContentSplitterOptions, SplitOptions } from "./ContentSplitter.js";
+import { ContentSplitterBase } from "./ContentSplitterBase.js";
+/**
+ * Content splitter for version 2, which supports segmenter-based splitting.
+ */
+export declare class ContentSplitterV2 extends ContentSplitterBase {
+    static isAvailableFor(setting: ContentSplitterOptions): boolean;
+    processSplit(options: SplitOptions): Promise<AsyncGenerator<string, void, unknown> | Generator<string, void, unknown>>;
+}

package/dist/ContentSplitter/ContentSplitterV2.js

@@ -0,0 +1,34 @@
+import { ChunkAlgorithms } from "../common/types.js";
+import { splitPieces2V2 } from "../string_and_binary/chunks.js";
+import { splitPieces2WorkerV2 } from "#worker";
+import { ContentSplitterBase } from "./ContentSplitterBase.js";
+class ContentSplitterV2 extends ContentSplitterBase {
+  static isAvailableFor(setting) {
+    const settings = setting.settingService.currentSettings();
+    return settings.chunkSplitterVersion === ChunkAlgorithms.V2 || settings.chunkSplitterVersion === ChunkAlgorithms.V2Segmenter;
+  }
+  async processSplit(options) {
+    if (options.useWorker) {
+      return (await splitPieces2WorkerV2(
+        options.blob,
+        options.pieceSize,
+        options.plainSplit,
+        options.minimumChunkSize,
+        options.path,
+        options.useSegmenter
+      ))();
+    } else {
+      return (await splitPieces2V2(
+        options.blob,
+        options.pieceSize,
+        options.plainSplit,
+        options.minimumChunkSize,
+        options.path,
+        options.useSegmenter
+      ))();
+    }
+  }
+}
+export {
+  ContentSplitterV2
+};

package/dist/ContentSplitter/ContentSplitters.d.ts

@@ -0,0 +1,12 @@
+import type { SavingEntry } from "../common/types.js";
+import type { ContentSplitterOptions } from "./ContentSplitter.js";
+import { ContentSplitterCore, type ContentSplitterBase } from "./ContentSplitterBase.js";
+/**
+ * ContentSplitter class that manages the active content splitter based on the provided settings.
+ */
+export declare class ContentSplitter extends ContentSplitterCore {
+    _activeSplitter: ContentSplitterBase;
+    constructor(options: ContentSplitterOptions);
+    initialise(options: ContentSplitterOptions): Promise<boolean>;
+    splitContent(entry: SavingEntry): Promise<AsyncGenerator<string, void, unknown> | Generator<string, void, unknown>>;
+}

package/dist/ContentSplitter/ContentSplitters.js

@@ -0,0 +1,29 @@
+import { ContentSplitterCore } from "./ContentSplitterBase.js";
+import { ContentSplitterRabinKarp } from "./ContentSplitterRabinKarp.js";
+import { ContentSplitterV1 } from "./ContentSplitterV1.js";
+import { ContentSplitterV2 } from "./ContentSplitterV2.js";
+const ContentSplitters = [ContentSplitterV1, ContentSplitterV2, ContentSplitterRabinKarp];
+class ContentSplitter extends ContentSplitterCore {
+  constructor(options) {
+    super(options);
+  }
+  initialise(options) {
+    for (const Splitter of ContentSplitters) {
+      if (Splitter.isAvailableFor(options)) {
+        this._activeSplitter = new Splitter(options);
+        break;
+      }
+    }
+    if (!this._activeSplitter) {
+      throw new Error(`ContentSplitter: No available splitter for settings!!`);
+    }
+    return this._activeSplitter.initialise(options);
+  }
+  async splitContent(entry) {
+    await this.initialised;
+    return this._activeSplitter.splitContent(entry);
+  }
+}
+export {
+  ContentSplitter
+};

package/dist/bureau/bureau.d.ts

@@ -0,0 +1,7 @@
+import { type SlipBoard } from "octagonal-wheels/bureau/SlipBoard";
+declare global {
+    interface Slips extends LSSlips {
+        _dummy: undefined;
+    }
+}
+export declare const globalSlipBoard: SlipBoard<Slips>;

package/dist/bureau/bureau.js

@@ -0,0 +1,5 @@
+import { globalSlipBoard as globalSlipBoard_ } from "octagonal-wheels/bureau/SlipBoard";
+const globalSlipBoard = globalSlipBoard_;
+export {
+  globalSlipBoard
+};

package/dist/common/ConnectionString.d.ts

@@ -0,0 +1,30 @@
+import type { CouchDBConnection, BucketSyncSetting, P2PConnectionInfo } from "./models/setting.type.js";
+export type RemoteConfigurationResult = {
+    type: "couchdb";
+    settings: CouchDBConnection;
+} | {
+    type: "s3";
+    settings: BucketSyncSetting;
+} | {
+    type: "p2p";
+    settings: P2PConnectionInfo;
+} | {
+    type: "webdav";
+    settings: never;
+};
+export declare class ConnectionStringParser {
+    /**
+     * Restore settings from URI
+     */
+    static parse(uriString: string): RemoteConfigurationResult;
+    /**
+     * 設定からURIを生成する
+     */
+    static serialize(config: RemoteConfigurationResult): string;
+    private static parseCouchDB;
+    private static serializeCouchDB;
+    private static parseS3;
+    private static serializeS3;
+    private static parseP2P;
+    private static serializeP2P;
+}