obsidian-dev-utils 94.5.0 → 94.6.0

package/dist/lib/esm/jpeg-metadata.mjs

@@ -0,0 +1,169 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function initEsm() {
+  // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+  if (globalThis.process) {
+    return;
+  }
+
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return '/';
+    },
+    env: {},
+    platform: 'android'
+  };
+  // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+  globalThis.process = browserProcess;
+})();
+
+const APP0_MARKER = 224;
+const APP1_MARKER = 225;
+const APP2_MARKER = 226;
+const EOI_MARKER = 217;
+const MARKER_PREFIX = 255;
+const SOI_MARKER = 216;
+const SOS_MARKER = 218;
+const EXIF_HEADER = "Exif\0\0";
+const ICC_PROFILE_HEADER = "ICC_PROFILE\0";
+const XMP_HEADER = "http://ns.adobe.com/xap/1.0/\0";
+const SEGMENT_HEADER_SIZE = 4;
+const SEGMENT_LENGTH_SIZE = 2;
+const SOI_SIZE = 2;
+const BIG_ENDIAN_TIFF_BYTE_ORDER = 19789;
+const IFD_ENTRY_SIZE = 12;
+const IFD_ENTRY_VALUE_OFFSET = 8;
+const IFD_ENTRY_COUNT_SIZE = 2;
+const LITTLE_ENDIAN_TIFF_BYTE_ORDER = 18761;
+const ORIENTATION_TAG = 274;
+const ORIENTATION_UPRIGHT = 1;
+const TIFF_HEADER_SIZE = 8;
+const TIFF_IFD_POINTER_OFFSET = 4;
+const TIFF_MAGIC = 42;
+const TIFF_MAGIC_OFFSET = 2;
+function extractJpegMetadataSegments(bytes) {
+  if (!checkIsJpeg(bytes)) {
+    return [];
+  }
+  const view = createView(bytes);
+  const segments = [];
+  let offset = SOI_SIZE;
+  while (offset + SEGMENT_HEADER_SIZE <= bytes.length) {
+    if (bytes[offset] !== MARKER_PREFIX) {
+      break;
+    }
+    const marker = bytes[offset + 1];
+    if (marker === SOS_MARKER || marker === EOI_MARKER) {
+      break;
+    }
+    const segmentLength = view.getUint16(offset + SEGMENT_LENGTH_SIZE);
+    const segmentEnd = offset + SEGMENT_LENGTH_SIZE + segmentLength;
+    if (segmentLength < SEGMENT_LENGTH_SIZE || segmentEnd > bytes.length) {
+      break;
+    }
+    if (checkIsMetadataSegment(bytes, offset, marker)) {
+      segments.push(bytes.slice(offset, segmentEnd));
+    }
+    offset = segmentEnd;
+  }
+  return segments;
+}
+function injectJpegMetadataSegments(jpegBytes, segments) {
+  if (segments.length === 0 || !checkIsJpeg(jpegBytes)) {
+    return jpegBytes;
+  }
+  const normalizedSegments = segments.map((segment) => normalizeOrientation(segment));
+  const insertAt = findInsertOffset(jpegBytes);
+  const addedLength = normalizedSegments.reduce((total, segment) => total + segment.length, 0);
+  const result = new Uint8Array(jpegBytes.length + addedLength);
+  result.set(jpegBytes.subarray(0, insertAt), 0);
+  let writeAt = insertAt;
+  for (const segment of normalizedSegments) {
+    result.set(segment, writeAt);
+    writeAt += segment.length;
+  }
+  result.set(jpegBytes.subarray(insertAt), writeAt);
+  return result;
+}
+function checkIsJpeg(bytes) {
+  return bytes.length >= SOI_SIZE && bytes[0] === MARKER_PREFIX && bytes[1] === SOI_MARKER;
+}
+function checkIsMetadataSegment(bytes, offset, marker) {
+  const payloadOffset = offset + SEGMENT_HEADER_SIZE;
+  if (marker === APP1_MARKER) {
+    return checkMatchesHeader(bytes, payloadOffset, EXIF_HEADER) || checkMatchesHeader(bytes, payloadOffset, XMP_HEADER);
+  }
+  if (marker === APP2_MARKER) {
+    return checkMatchesHeader(bytes, payloadOffset, ICC_PROFILE_HEADER);
+  }
+  return false;
+}
+function checkMatchesHeader(bytes, offset, header) {
+  if (offset + header.length > bytes.length) {
+    return false;
+  }
+  for (let index = 0; index < header.length; index++) {
+    if (bytes[offset + index] !== header.codePointAt(index)) {
+      return false;
+    }
+  }
+  return true;
+}
+function createView(bytes) {
+  return new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+}
+function findInsertOffset(jpegBytes) {
+  if (SOI_SIZE + SEGMENT_HEADER_SIZE > jpegBytes.length) {
+    return SOI_SIZE;
+  }
+  if (jpegBytes[SOI_SIZE] !== MARKER_PREFIX || jpegBytes[SOI_SIZE + 1] !== APP0_MARKER) {
+    return SOI_SIZE;
+  }
+  const app0End = SOI_SIZE + SEGMENT_LENGTH_SIZE + createView(jpegBytes).getUint16(SOI_SIZE + SEGMENT_LENGTH_SIZE);
+  return app0End > jpegBytes.length ? SOI_SIZE : app0End;
+}
+function normalizeOrientation(segment) {
+  if (segment[1] !== APP1_MARKER || !checkMatchesHeader(segment, SEGMENT_HEADER_SIZE, EXIF_HEADER)) {
+    return segment;
+  }
+  const tiffOffset = SEGMENT_HEADER_SIZE + EXIF_HEADER.length;
+  if (tiffOffset + TIFF_HEADER_SIZE > segment.length) {
+    return segment;
+  }
+  const view = createView(segment);
+  const byteOrder = view.getUint16(tiffOffset);
+  const isLittleEndian = byteOrder === LITTLE_ENDIAN_TIFF_BYTE_ORDER;
+  if (!isLittleEndian && byteOrder !== BIG_ENDIAN_TIFF_BYTE_ORDER) {
+    return segment;
+  }
+  if (view.getUint16(tiffOffset + TIFF_MAGIC_OFFSET, isLittleEndian) !== TIFF_MAGIC) {
+    return segment;
+  }
+  const ifdOffset = tiffOffset + view.getUint32(tiffOffset + TIFF_IFD_POINTER_OFFSET, isLittleEndian);
+  if (ifdOffset + IFD_ENTRY_COUNT_SIZE > segment.length) {
+    return segment;
+  }
+  const entryCount = view.getUint16(ifdOffset, isLittleEndian);
+  const entriesOffset = ifdOffset + IFD_ENTRY_COUNT_SIZE;
+  if (entriesOffset + entryCount * IFD_ENTRY_SIZE > segment.length) {
+    return segment;
+  }
+  const result = new Uint8Array(segment);
+  const resultView = createView(result);
+  for (let index = 0; index < entryCount; index++) {
+    const entryOffset = entriesOffset + index * IFD_ENTRY_SIZE;
+    if (resultView.getUint16(entryOffset, isLittleEndian) === ORIENTATION_TAG) {
+      resultView.setUint16(entryOffset + IFD_ENTRY_VALUE_OFFSET, ORIENTATION_UPRIGHT, isLittleEndian);
+    }
+  }
+  return result;
+}
+export {
+  extractJpegMetadataSegments,
+  injectJpegMetadataSegments
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/jpeg-metadata.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Reads and re-attaches a JPEG's metadata segments.\n *\n * Re-encoding an image through a canvas keeps only pixels: EXIF, GPS, XMP and the ICC profile are all\n * dropped by construction, because the canvas holds decoded samples and nothing else. These helpers\n * lift the metadata segments off the original bytes so they can be spliced back into the re-encoded\n * JPEG.\n */\n\nconst APP0_MARKER = 0xE0;\nconst APP1_MARKER = 0xE1;\nconst APP2_MARKER = 0xE2;\nconst EOI_MARKER = 0xD9;\nconst MARKER_PREFIX = 0xFF;\nconst SOI_MARKER = 0xD8;\nconst SOS_MARKER = 0xDA;\n\nconst EXIF_HEADER = 'Exif\\0\\0';\nconst ICC_PROFILE_HEADER = 'ICC_PROFILE\\0';\n// eslint-disable-next-line unicorn/prefer-https -- The literal bytes Adobe writes into the `APP1` segment. It is a namespace identifier, never fetched, and rewriting it to `https` would stop XMP from ever matching.\nconst XMP_HEADER = 'http://ns.adobe.com/xap/1.0/\\0';\n\n/**\n * Bytes from the start of a segment to its payload: the two marker bytes plus the two length bytes.\n */\nconst SEGMENT_HEADER_SIZE = 4;\n\n/**\n * The segment length field itself counts the two bytes it occupies.\n */\nconst SEGMENT_LENGTH_SIZE = 2;\n\n/**\n * The `SOI` marker that opens every JPEG.\n */\nconst SOI_SIZE = 2;\n\nconst BIG_ENDIAN_TIFF_BYTE_ORDER = 0x4D_4D;\nconst IFD_ENTRY_SIZE = 12;\n/**\n * Bytes from the start of an IFD entry to its inline value: tag (2) + type (2) + count (4).\n */\nconst IFD_ENTRY_VALUE_OFFSET = 8;\nconst IFD_ENTRY_COUNT_SIZE = 2;\nconst LITTLE_ENDIAN_TIFF_BYTE_ORDER = 0x49_49;\nconst ORIENTATION_TAG = 0x01_12;\nconst ORIENTATION_UPRIGHT = 1;\nconst TIFF_HEADER_SIZE = 8;\nconst TIFF_IFD_POINTER_OFFSET = 4;\nconst TIFF_MAGIC = 0x00_2A;\nconst TIFF_MAGIC_OFFSET = 2;\n\n/**\n * Extracts the metadata segments of a JPEG.\n *\n * Returns each matching segment whole \u2014 marker, length and payload \u2014 so\n * {@link injectJpegMetadataSegments} can splice it into another JPEG untouched. Only the segments that\n * carry metadata are returned: the EXIF and XMP `APP1`s and the ICC profile `APP2`. `APP0` (JFIF) is\n * deliberately left behind, because the re-encoded JPEG writes its own.\n *\n * Returns an empty array for anything that is not a JPEG, including a truncated or malformed one \u2014 a\n * caller that cannot preserve metadata should carry on without it rather than fail.\n *\n * @param bytes - The bytes of the source image.\n * @returns The metadata segments, in the order they appeared.\n */\nexport function extractJpegMetadataSegments(bytes: Uint8Array): Uint8Array[] {\n  if (!checkIsJpeg(bytes)) {\n    return [];\n  }\n\n  const view = createView(bytes);\n  const segments: Uint8Array[] = [];\n  let offset = SOI_SIZE;\n\n  while (offset + SEGMENT_HEADER_SIZE <= bytes.length) {\n    if (bytes[offset] !== MARKER_PREFIX) {\n      break;\n    }\n\n    const marker = bytes[offset + 1];\n    if (marker === SOS_MARKER || marker === EOI_MARKER) {\n      break;\n    }\n\n    const segmentLength = view.getUint16(offset + SEGMENT_LENGTH_SIZE);\n    const segmentEnd = offset + SEGMENT_LENGTH_SIZE + segmentLength;\n    if (segmentLength < SEGMENT_LENGTH_SIZE || segmentEnd > bytes.length) {\n      break;\n    }\n\n    if (checkIsMetadataSegment(bytes, offset, marker)) {\n      segments.push(bytes.slice(offset, segmentEnd));\n    }\n\n    offset = segmentEnd;\n  }\n\n  return segments;\n}\n\n/**\n * Splices metadata segments into a JPEG.\n *\n * The segments go directly after the `SOI` and the re-encoded JPEG's own `APP0`, which is where a\n * reader expects to find them.\n *\n * Every copied EXIF block has its orientation tag reset to upright. The canvas decode already applied\n * the original orientation to the pixels, so carrying the tag across verbatim would rotate the image a\n * second time \u2014 the one piece of metadata that is wrong to preserve as-is.\n *\n * @param jpegBytes - The bytes of the re-encoded JPEG.\n * @param segments - The segments returned by {@link extractJpegMetadataSegments}.\n * @returns The JPEG with the segments spliced in, or the input unchanged when there is nothing to add\n *   or the input is not a JPEG.\n */\nexport function injectJpegMetadataSegments(jpegBytes: Uint8Array, segments: readonly Uint8Array[]): Uint8Array {\n  if (segments.length === 0 || !checkIsJpeg(jpegBytes)) {\n    return jpegBytes;\n  }\n\n  const normalizedSegments = segments.map((segment) => normalizeOrientation(segment));\n  const insertAt = findInsertOffset(jpegBytes);\n  const addedLength = normalizedSegments.reduce((total, segment) => total + segment.length, 0);\n  const result = new Uint8Array(jpegBytes.length + addedLength);\n\n  result.set(jpegBytes.subarray(0, insertAt), 0);\n  let writeAt = insertAt;\n  for (const segment of normalizedSegments) {\n    result.set(segment, writeAt);\n    writeAt += segment.length;\n  }\n  result.set(jpegBytes.subarray(insertAt), writeAt);\n\n  return result;\n}\n\nfunction checkIsJpeg(bytes: Uint8Array): boolean {\n  return bytes.length >= SOI_SIZE && bytes[0] === MARKER_PREFIX && bytes[1] === SOI_MARKER;\n}\n\nfunction checkIsMetadataSegment(bytes: Uint8Array, offset: number, marker: number | undefined): boolean {\n  const payloadOffset = offset + SEGMENT_HEADER_SIZE;\n  if (marker === APP1_MARKER) {\n    return checkMatchesHeader(bytes, payloadOffset, EXIF_HEADER) || checkMatchesHeader(bytes, payloadOffset, XMP_HEADER);\n  }\n  if (marker === APP2_MARKER) {\n    return checkMatchesHeader(bytes, payloadOffset, ICC_PROFILE_HEADER);\n  }\n  return false;\n}\n\nfunction checkMatchesHeader(bytes: Uint8Array, offset: number, header: string): boolean {\n  if (offset + header.length > bytes.length) {\n    return false;\n  }\n  for (let index = 0; index < header.length; index++) {\n    if (bytes[offset + index] !== header.codePointAt(index)) {\n      return false;\n    }\n  }\n  return true;\n}\n\nfunction createView(bytes: Uint8Array): DataView {\n  return new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);\n}\n\nfunction findInsertOffset(jpegBytes: Uint8Array): number {\n  if (SOI_SIZE + SEGMENT_HEADER_SIZE > jpegBytes.length) {\n    return SOI_SIZE;\n  }\n  if (jpegBytes[SOI_SIZE] !== MARKER_PREFIX || jpegBytes[SOI_SIZE + 1] !== APP0_MARKER) {\n    return SOI_SIZE;\n  }\n\n  const app0End = SOI_SIZE + SEGMENT_LENGTH_SIZE + createView(jpegBytes).getUint16(SOI_SIZE + SEGMENT_LENGTH_SIZE);\n  return app0End > jpegBytes.length ? SOI_SIZE : app0End;\n}\n\nfunction normalizeOrientation(segment: Uint8Array): Uint8Array {\n  if (segment[1] !== APP1_MARKER || !checkMatchesHeader(segment, SEGMENT_HEADER_SIZE, EXIF_HEADER)) {\n    return segment;\n  }\n\n  const tiffOffset = SEGMENT_HEADER_SIZE + EXIF_HEADER.length;\n  if (tiffOffset + TIFF_HEADER_SIZE > segment.length) {\n    return segment;\n  }\n\n  const view = createView(segment);\n  const byteOrder = view.getUint16(tiffOffset);\n  const isLittleEndian = byteOrder === LITTLE_ENDIAN_TIFF_BYTE_ORDER;\n  if (!isLittleEndian && byteOrder !== BIG_ENDIAN_TIFF_BYTE_ORDER) {\n    return segment;\n  }\n\n  if (view.getUint16(tiffOffset + TIFF_MAGIC_OFFSET, isLittleEndian) !== TIFF_MAGIC) {\n    return segment;\n  }\n\n  const ifdOffset = tiffOffset + view.getUint32(tiffOffset + TIFF_IFD_POINTER_OFFSET, isLittleEndian);\n  if (ifdOffset + IFD_ENTRY_COUNT_SIZE > segment.length) {\n    return segment;\n  }\n\n  const entryCount = view.getUint16(ifdOffset, isLittleEndian);\n  const entriesOffset = ifdOffset + IFD_ENTRY_COUNT_SIZE;\n  if (entriesOffset + entryCount * IFD_ENTRY_SIZE > segment.length) {\n    return segment;\n  }\n\n  const result = new Uint8Array(segment);\n  const resultView = createView(result);\n  for (let index = 0; index < entryCount; index++) {\n    const entryOffset = entriesOffset + index * IFD_ENTRY_SIZE;\n    if (resultView.getUint16(entryOffset, isLittleEndian) === ORIENTATION_TAG) {\n      resultView.setUint16(entryOffset + IFD_ENTRY_VALUE_OFFSET, ORIENTATION_UPRIGHT, isLittleEndian);\n    }\n  }\n\n  return result;\n}\n"],
  "mappings": "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",
  "names": []
}


package/dist/lib/esm/obsidian/attachment-unit-folder.d.mts

@@ -0,0 +1,73 @@
+/// <reference path="../library.d.mts" />
+/**
+ * @file
+ *
+ * Resolves which folder an attachment belongs to when the user has designated folders that must
+ * travel as a single unit.
+ *
+ * Some formats are really a directory tree rather than a file: a page saved from a browser sits next
+ * to a `_files/` folder holding its images and stylesheets, an `.excalidraw` sits next to the images
+ * it references. Relocating only the linked file leaves the rest behind and the attachment arrives
+ * broken.
+ *
+ * This lives in the shared library rather than in one plugin because more than one plugin relocates
+ * attachments over the same vault. If they each decided separately what one attachment is, a user
+ * with both installed would get a folder kept whole by one and torn apart by the other.
+ */
+/**
+ * Parameters for {@link findAttachmentUnitFolderPath}.
+ */
+export interface FindAttachmentUnitFolderPathParams {
+    /**
+     * The vault-relative path of the attachment.
+     */
+    readonly attachmentPath: string;
+    /**
+     * Whether a folder path is designated as an attachment unit.
+     *
+     * @param folderPath - The vault-relative path of the folder.
+     * @returns `true` if the folder is designated as an attachment unit, `false` otherwise.
+     */
+    checkIsAttachmentUnitFolder(folderPath: string): boolean;
+}
+/**
+ * Parameters for {@link rebasePathOntoFolder}.
+ */
+export interface RebasePathOntoFolderParams {
+    /**
+     * The folder's new path.
+     */
+    readonly newFolderPath: string;
+    /**
+     * The folder's old path.
+     */
+    readonly oldFolderPath: string;
+    /**
+     * The path to rebase.
+     */
+    readonly path: string;
+}
+/**
+ * Finds the folder that an attachment must travel with.
+ *
+ * Returns the **outermost** designated ancestor, not the nearest one. With nested designations,
+ * moving the nearest would tear the outer tree in half, which is the failure the whole feature exists
+ * to prevent.
+ *
+ * The vault root is never a unit, however the patterns are written: designating it would make every
+ * relocation a no-op at best and a vault-wide move at worst.
+ *
+ * @param params - The parameters for finding the attachment unit folder.
+ * @returns The unit folder's path, or `null` when the attachment belongs to no unit.
+ */
+export declare function findAttachmentUnitFolderPath(params: FindAttachmentUnitFolderPathParams): null | string;
+/**
+ * Rebases a path from one folder onto another.
+ *
+ * Used to work out where a linked attachment ends up once its whole unit folder has moved, so the
+ * link can be pointed at the file's new home rather than at where the folder used to be.
+ *
+ * @param params - The parameters for rebasing the path.
+ * @returns The rebased path, or `null` when the path does not sit inside the old folder.
+ */
+export declare function rebasePathOntoFolder(params: RebasePathOntoFolderParams): null | string;

package/dist/lib/esm/obsidian/attachment-unit-folder.mjs

@@ -0,0 +1,50 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function initEsm() {
+  // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+  if (globalThis.process) {
+    return;
+  }
+
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return '/';
+    },
+    env: {},
+    platform: 'android'
+  };
+  // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+  globalThis.process = browserProcess;
+})();
+
+import { dirname } from "../path.mjs";
+function findAttachmentUnitFolderPath(params) {
+  const parentFolderPath = dirname(params.attachmentPath);
+  if (!parentFolderPath || parentFolderPath === "." || parentFolderPath === "/") {
+    return null;
+  }
+  const segments = parentFolderPath.split("/").filter(Boolean);
+  for (let count = 1; count <= segments.length; count++) {
+    const candidate = segments.slice(0, count).join("/");
+    if (params.checkIsAttachmentUnitFolder(candidate)) {
+      return candidate;
+    }
+  }
+  return null;
+}
+function rebasePathOntoFolder(params) {
+  const prefix = `${params.oldFolderPath}/`;
+  if (!params.path.startsWith(prefix)) {
+    return null;
+  }
+  return `${params.newFolderPath}/${params.path.slice(prefix.length)}`;
+}
+export {
+  findAttachmentUnitFolderPath,
+  rebasePathOntoFolder
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/obsidian/components/plugin-settings-component.mjs

@@ -178,6 +178,9 @@ class PluginSettingsComponentBase extends ComponentEx {
         });
       }
       this.lastSavedState = await this.cloneState(this.currentState);
+      if (this.propertyNames.length === 0) {
+        return;
+      }
       const newRecord = await this.settingsToRawRecord(this.currentState.inputValues);
       if (!isDeepEqual(newRecord, data)) {
         await this.saveToFileImpl();
@@ -504,4 +507,4 @@ class PluginSettingsComponentBase extends ComponentEx {
 export {
   PluginSettingsComponentBase
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../../src/obsidian/components/plugin-settings-component.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Component that manages plugin settings: data, persistence, validation, and events.\n *\n * This is the single public-facing settings API for plugin authors.\n * All settings logic (load, save, validate, transform, clone) is handled directly\n * by this component \u2014 no separate manager class is needed.\n */\n\nimport type {\n  Constructor,\n  Promisable,\n  ReadonlyDeep\n} from 'type-fest';\n\nimport type {\n  AsyncEventRef,\n  AsyncEventSource\n} from '../../async-events.ts';\nimport type { Transformer } from '../../transformers/transformer.ts';\nimport type { GenericObject } from '../../type-guards.ts';\nimport type {\n  MaybeReturn,\n  StringKeys\n} from '../../type.ts';\nimport type { DataHandler } from '../data-handler.ts';\nimport type { PluginEventSource } from '../plugin/plugin-event-source.ts';\n\nimport { AsyncEvents } from '../../async-events.ts';\nimport { getLibDebugger } from '../../debug.ts';\nimport {\n  noop,\n  noopAsync\n} from '../../function.ts';\nimport {\n  castTo,\n  getAllKeys,\n  isDeepEqual\n} from '../../object-utils.ts';\nimport { DateTransformer } from '../../transformers/date-transformer.ts';\nimport { DurationTransformer } from '../../transformers/duration-transformer.ts';\nimport { GroupTransformer } from '../../transformers/group-transformer.ts';\nimport { MapTransformer } from '../../transformers/map-transformer.ts';\nimport { SetTransformer } from '../../transformers/set-transformer.ts';\nimport { SkipPrivatePropertyTransformer } from '../../transformers/skip-private-property-transformer.ts';\nimport { TwoWayMapTransformer } from '../../transformers/two-way-map-transformer.ts';\nimport { ValueWrapper } from '../../value-wrapper.ts';\nimport { registerAsyncEvent } from './async-events-component.ts';\nimport { ComponentEx } from './component-ex.ts';\n\nconst defaultTransformer = new GroupTransformer([\n  new SkipPrivatePropertyTransformer(),\n  new DateTransformer(),\n  new DurationTransformer(),\n  new MapTransformer(),\n  new SetTransformer(),\n  new TwoWayMapTransformer()\n]);\n\n/**\n * Constructor parameters for {@link PluginSettingsComponentBase}.\n *\n * @typeParam PluginSettings - The type of the plugin settings.\n */\nexport interface PluginSettingsComponentBaseConstructorParams<PluginSettings> {\n  /**\n   * The data handler for the plugin.\n   */\n  readonly dataHandler: DataHandler;\n\n  /**\n   * The plugin events.\n   */\n  readonly pluginEventSource: PluginEventSource;\n\n  /**\n   * The plugin settings class.\n   */\n  readonly pluginSettingsClass: Constructor<PluginSettings, []>;\n}\n\n/**\n * Parameters for {@link PluginSettingsComponentBase.onSaveSettings}.\n *\n * @typeParam PluginSettings - The type of the plugin settings.\n */\nexport interface PluginSettingsComponentBaseOnSaveSettingsParams<PluginSettings extends object> {\n  /**\n   * The save context.\n   */\n  readonly context: unknown;\n\n  /**\n   * The new settings state.\n   */\n  readonly newState: ReadonlyPluginSettingsState<PluginSettings>;\n\n  /**\n   * The old settings state.\n   */\n  readonly oldState: ReadonlyPluginSettingsState<PluginSettings>;\n}\n\n/**\n * A snapshot of plugin settings state, including raw input values, effective (validated) values,\n * and per-property validation messages.\n *\n * @typeParam PluginSettings - The type of the plugin settings.\n */\nexport interface PluginSettingsState<PluginSettings extends object> {\n  /**\n   * The effective settings values used by the plugin. Invalid properties are replaced with defaults.\n   */\n  effectiveValues: PluginSettings;\n\n  /**\n   * The raw input values as entered by the user. May contain invalid values.\n   */\n  inputValues: PluginSettings;\n\n  /**\n   * Per-property validation messages. Empty string means valid.\n   */\n  validationMessages: Record<StringKeys<PluginSettings>, string>;\n}\n\n/**\n * Readonly version of {@link PluginSettings}.\n *\n * @typeParam PluginSettings - The type of the plugin settings.\n */\nexport type ReadonlyPluginSettings<PluginSettings extends object> = ReadonlyDeep<PluginSettings>;\n\n/**\n * Readonly version of {@link PluginSettingsState} for use in event callbacks and public getters.\n *\n * @typeParam PluginSettings - The type of the plugin settings.\n */\nexport type ReadonlyPluginSettingsState<PluginSettings extends object> = ReadonlyDeep<PluginSettingsState<PluginSettings>>;\n\n/**\n * A validator function for a settings property.\n *\n * @typeParam PluginSettings - The plugin settings type.\n * @typeParam PropertyName - The property name.\n */\nexport type SettingsValidator<PluginSettings extends object, PropertyName extends StringKeys<PluginSettings> = StringKeys<PluginSettings>> = (\n  value: PluginSettings[PropertyName],\n  settings: PluginSettings\n) => Promisable<MaybeReturn<string>>;\n\ninterface PluginSettingsComponentBaseEventMap<PluginSettings extends object> {\n  loadSettings: [\n    loadedState: ReadonlyPluginSettingsState<PluginSettings>,\n    isInitialLoad: boolean\n  ];\n  saveSettings: [\n    newState: ReadonlyPluginSettingsState<PluginSettings>,\n    oldState: ReadonlyPluginSettingsState<PluginSettings>,\n    context: unknown\n  ];\n}\n\n/**\n * Parameters for {@link PluginSettingsComponentBase.setPropertyImpl}.\n *\n * @typeParam PluginSettings - The type of the plugin settings.\n */\ninterface PluginSettingsComponentBaseSetPropertyImplParams<PluginSettings extends object> {\n  /**\n   * The name of the property to set.\n   */\n  readonly propertyName: PropertyNames<PluginSettings>;\n\n  /**\n   * The validation message. Empty or unset means valid.\n   */\n  readonly validationMessage?: string | undefined;\n\n  /**\n   * The value to set.\n   */\n  readonly value: PropertyValues<PluginSettings>;\n}\n\ntype PropertyNames<PluginSettings extends object> = StringKeys<PluginSettings>;\n\ntype PropertyValues<PluginSettings extends object> = PluginSettings[PropertyNames<PluginSettings>];\n\ntype ValidationResult<PluginSettings extends object> = Partial<Record<StringKeys<PluginSettings>, string>>;\n\n/**\n * Base class for plugin settings components.\n *\n * Manages settings data, persistence, validation, and events.\n * Plugin authors extend this class and implement {@link createDefaultSettings}.\n *\n * @typeParam PluginSettings - The plugin settings type.\n */\n// eslint-disable-next-line obsidian-dev-utils/require-component-suffix -- Non-abstract base class; consumers extend it.\nexport class PluginSettingsComponentBase<PluginSettings extends object> extends ComponentEx implements AsyncEventSource<PluginSettingsComponentBaseEventMap<PluginSettings>> {\n  /**\n   * Gets the readonly default settings.\n   *\n   * @returns The default settings (as a readonly object).\n   */\n  public readonly defaultSettings: ReadonlyDeep<PluginSettings>;\n\n  /**\n   * Gets the readonly effective settings (validated, with defaults substituted for invalid values).\n   *\n   * @returns The readonly effective settings.\n   */\n  public get settings(): ReadonlyDeep<PluginSettings> {\n    return this.settingsState.effectiveValues;\n  }\n\n  /**\n   * Gets the current settings state snapshot.\n   *\n   * @returns The current settings state.\n   */\n  public get settingsState(): ReadonlyPluginSettingsState<PluginSettings> {\n    return this.currentState as ReadonlyPluginSettingsState<PluginSettings>;\n  }\n\n  /**\n   * The data handler used to load and save the plugin settings.\n   */\n  protected readonly dataHandler: DataHandler;\n  /**\n   * The plugin event source the component listens to for external settings changes.\n   */\n  protected readonly pluginEventSource: PluginEventSource;\n\n  /**\n   * The plugin settings class used to construct settings instances.\n   */\n  protected readonly pluginSettingsClass: Constructor<PluginSettings, []>;\n  private readonly asyncEvents = new AsyncEvents<PluginSettingsComponentBaseEventMap<PluginSettings>>();\n  private currentState: PluginSettingsState<PluginSettings>;\n\n  private lastSavedState: PluginSettingsState<PluginSettings>;\n\n  private readonly legacySettingsConverters: ((record: GenericObject) => void)[] = [];\n  private readonly propertyNames: PropertyNames<PluginSettings>[];\n\n  private readonly validators = new Map<PropertyNames<PluginSettings>, SettingsValidator<PluginSettings>>();\n\n  /**\n   * Creates a new plugin settings component.\n   *\n   * @param params - The constructor parameters.\n   */\n  public constructor(params: PluginSettingsComponentBaseConstructorParams<PluginSettings>) {\n    super();\n    this.dataHandler = params.dataHandler;\n    this.pluginSettingsClass = params.pluginSettingsClass;\n    this.pluginEventSource = params.pluginEventSource;\n\n    this.defaultSettings = new this.pluginSettingsClass() as ReadonlyDeep<PluginSettings>;\n    this.currentState = this.createDefaultState();\n    this.lastSavedState = this.createDefaultState();\n    this.propertyNames = getAllKeys(this.currentState.inputValues);\n    this.registerValidators();\n    this.registerLegacySettingsConverters();\n  }\n\n  /**\n   * Edits the plugin settings and saves them.\n   *\n   * @param settingsEditor - The editor.\n   * @param context - The context.\n   * @returns A {@link Promise} that resolves when the settings are saved.\n   */\n  public async editAndSave(settingsEditor: (settings: PluginSettings) => Promisable<void>, context?: unknown): Promise<void> {\n    this.ensureLoaded();\n    await this.edit(settingsEditor);\n    await this.saveToFile(context);\n  }\n\n  /**\n   * Ensures the settings are safe.\n   *\n   * It runs validation for each property and sets the default value if the validation fails.\n   *\n   * @param settings - The settings.\n   * @returns A {@link Promise} that resolves when the settings are safe.\n   */\n  public async ensureSafe(settings: PluginSettings): Promise<void> {\n    const validationResult = await this.validate(settings);\n    const defaults = this.defaultSettings as PluginSettings;\n    for (const propertyName of this.propertyNames) {\n      // eslint-disable-next-line unicorn/no-computed-property-existence-check -- This tests whether a validation message is non-empty, not whether the key exists.\n      if (validationResult[propertyName]) {\n        settings[propertyName] = defaults[propertyName];\n      }\n    }\n  }\n\n  /**\n   * Gets a safe copy of the settings.\n   *\n   * @param settings - The settings.\n   * @returns A {@link Promise} that resolves to the safe copy of the settings.\n   */\n  public async getSafeCopy(settings: PluginSettings): Promise<PluginSettings> {\n    const safeSettings = await this.cloneSettings(settings);\n    await this.ensureSafe(safeSettings);\n    return safeSettings;\n  }\n\n  /**\n   * Loads the plugin settings from the file.\n   *\n   * @param isInitialLoad - Whether the settings are being loaded for the first time.\n   * @returns A {@link Promise} that resolves when the settings are loaded.\n   */\n  public async loadFromFile(isInitialLoad: boolean): Promise<void> {\n    this.ensureLoaded();\n    const data = await this.dataHandler.loadData();\n    this.lastSavedState = this.createDefaultState();\n    this.currentState = this.createDefaultState();\n\n    try {\n      if (data === undefined || data === null) {\n        return;\n      }\n\n      if (typeof data !== 'object') {\n        console.error(`Invalid settings from data.json. Expected Object, got: ${typeof data}`);\n        return;\n      }\n\n      const rawRecord = data as GenericObject;\n      const parsedSettings = await this.rawRecordToSettings(rawRecord);\n      const validationResult = await this.validate(parsedSettings);\n\n      for (const propertyName of this.propertyNames) {\n        this.setPropertyImpl({\n          propertyName,\n          validationMessage: validationResult[propertyName],\n          value: parsedSettings[propertyName]\n        });\n      }\n\n      this.lastSavedState = await this.cloneState(this.currentState);\n\n      const newRecord = await this.settingsToRawRecord(this.currentState.inputValues);\n\n      if (!isDeepEqual(newRecord, data)) {\n        await this.saveToFileImpl();\n      }\n    } finally {\n      await this.asyncEvents.triggerAsync('loadSettings', this.currentState as ReadonlyPluginSettingsState<PluginSettings>, isInitialLoad);\n    }\n  }\n\n  /**\n   * Remove an event listener.\n   *\n   * @typeParam EventName - The name of the event.\n   * @typeParam Arguments - The types of the arguments the event callback accepts.\n   * @param name - The name of the event.\n   * @param callback - The callback to remove.\n   */\n  public off<\n    EventName extends keyof PluginSettingsComponentBaseEventMap<PluginSettings>,\n    // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters -- We need to use the dummy parameter to get type inference.\n    Arguments extends EventName extends keyof PluginSettingsComponentBaseEventMap<PluginSettings> ? PluginSettingsComponentBaseEventMap<PluginSettings>[EventName]\n      : unknown[]\n  >(name: EventName, callback: (...$arguments: Arguments) => Promisable<void>): void {\n    this.asyncEvents.off(name, callback);\n  }\n\n  /**\n   * Remove an event listener by reference.\n   *\n   * @param eventRef - The reference to the event listener.\n   */\n  public offref(eventRef: AsyncEventRef): void {\n    this.asyncEvents.offref(eventRef);\n  }\n\n  /**\n   * Add an event listener.\n   *\n   * @typeParam EventName - The name of the event.\n   * @typeParam Arguments - The types of the arguments the event callback accepts.\n   * @param name - The name of the event.\n   * @param callback - The callback to call when the event is triggered.\n   * @param thisArgument - The context passed as `this` to the `callback`.\n   * @returns A reference to the event listener.\n   *\n   * @remarks Not refactored to parameter-object pattern, to keep the parity with {@link obsidian#Events#on} (or once, correspondingly).\n   */\n  public on<\n    EventName extends keyof PluginSettingsComponentBaseEventMap<PluginSettings>,\n    // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters -- We need to use the dummy parameter to get type inference.\n    Arguments extends EventName extends keyof PluginSettingsComponentBaseEventMap<PluginSettings> ? PluginSettingsComponentBaseEventMap<PluginSettings>[EventName]\n      : unknown[]\n  >(name: EventName, callback: (...$arguments: Arguments) => Promisable<void>, thisArgument?: unknown): AsyncEventRef {\n    return this.asyncEvents.on(name, callback, thisArgument);\n  }\n\n  /**\n   * Trigger an event, executing all the listeners in order even if some of them throw an error.\n   *\n   * Add an event listener that will be called only once.\n   *\n   * @typeParam EventName - The name of the event.\n   * @typeParam Arguments - The types of the arguments the event callback accepts.\n   * @param name - The name of the event.\n   * @param callback - The callback to call when the event is triggered.\n   * @param thisArgument - The context passed as `this` to the `callback`.\n   * @returns A reference to the event listener.\n   *\n   * @remarks Not refactored to parameter-object pattern, to keep the parity with {@link obsidian#Events#on} (or once, correspondingly).\n   */\n  public once<\n    EventName extends keyof PluginSettingsComponentBaseEventMap<PluginSettings>,\n    // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters -- We need to use the dummy parameter to get type inference.\n    Arguments extends EventName extends keyof PluginSettingsComponentBaseEventMap<PluginSettings> ? PluginSettingsComponentBaseEventMap<PluginSettings>[EventName]\n      : unknown[]\n  >(name: EventName, callback: (...$arguments: Arguments) => Promisable<void>, thisArgument?: unknown): AsyncEventRef {\n    return this.asyncEvents.once(name, callback, thisArgument);\n  }\n\n  /**\n   * Called when the external settings change.\n   *\n   * @returns A {@link Promise} that resolves when the settings are reloaded.\n   */\n  public async onExternalSettingsChange(): Promise<void> {\n    this.ensureLoaded();\n    await this.loadFromFile(false);\n  }\n\n  /**\n   * Loads settings from file and registers event handlers.\n   */\n  public override async onloadAsync(): Promise<void> {\n    registerAsyncEvent(this, this.on('loadSettings', this.onLoadSettings.bind(this)));\n    registerAsyncEvent(this, this.on('saveSettings', (newState, oldState, context) => this.onSaveSettings({ context, newState, oldState })));\n    registerAsyncEvent(this, this.pluginEventSource.on('externalSettingsChange', this.onExternalSettingsChange.bind(this)));\n    await this.loadFromFile(true);\n  }\n\n  /**\n   * Registers a legacy settings converter.\n   *\n   * @typeParam LegacySettings - The legacy settings class.\n   * @param legacySettingsClass - The legacy settings class.\n   * @param converter - The converter.\n   */\n  public registerLegacySettingsConverter<LegacySettings extends object>(\n    legacySettingsClass: new () => LegacySettings,\n    converter: (legacySettings: Partial<LegacySettings> & Partial<PluginSettings>) => void\n  ): void {\n    const thisWrapper = ValueWrapper.of(this);\n    this.legacySettingsConverters.push(legacySettingsConverter);\n\n    function legacySettingsConverter(record: GenericObject): void {\n      const legacySettingsKeys = new Set<string>(Object.keys(new legacySettingsClass()));\n      const pluginSettingKeys = new Set<string>(thisWrapper.value.propertyNames);\n      const legacySettings = record as Partial<LegacySettings> & Partial<PluginSettings>;\n      converter(legacySettings);\n      for (const key of Object.keys(legacySettings)) {\n        if (pluginSettingKeys.has(key)) {\n          continue;\n        }\n\n        if (!legacySettingsKeys.has(key)) {\n          continue;\n        }\n\n        // eslint-disable-next-line @typescript-eslint/no-dynamic-delete -- We have no other way to delete the property.\n        delete record[key];\n      }\n    }\n  }\n\n  /**\n   * Registers a validator for a property.\n   *\n   * @typeParam PropertyName - The name of the settings property.\n   * @param propertyName - The name of the property.\n   * @param validator - The validator.\n   */\n  public registerValidator<PropertyName extends PropertyNames<PluginSettings>>(\n    propertyName: PropertyName,\n    validator: SettingsValidator<PluginSettings, PropertyName>\n  ): void {\n    this.validators.set(propertyName, validator as SettingsValidator<PluginSettings>);\n  }\n\n  /**\n   * Revalidates the settings.\n   *\n   * @returns The validation messages.\n   */\n  public async revalidate(): Promise<Record<PropertyNames<PluginSettings>, string>> {\n    this.ensureLoaded();\n    await this.edit(noop);\n    return this.currentState.validationMessages;\n  }\n\n  /**\n   * Saves the new plugin settings.\n   *\n   * @param context - The context of the save to file operation.\n   * @returns A {@link Promise} that resolves when the settings are saved.\n   */\n  public async saveToFile(context?: unknown): Promise<void> {\n    this.ensureLoaded();\n    if (isDeepEqual(this.lastSavedState.inputValues, this.currentState.inputValues)) {\n      return;\n    }\n\n    await this.saveToFileImpl();\n    await this.asyncEvents.triggerAsync(\n      'saveSettings',\n      this.currentState as ReadonlyPluginSettingsState<PluginSettings>,\n      this.lastSavedState as ReadonlyPluginSettingsState<PluginSettings>,\n      context\n    );\n    this.lastSavedState = await this.cloneState(this.currentState);\n  }\n\n  /**\n   * Sets the value of a property.\n   *\n   * @typeParam PropertyName - The name of the property.\n   * @param propertyName - The name of the property.\n   * @param value - The value to set.\n   * @returns A {@link Promise} that resolves to the validation message.\n   */\n  public async setProperty<PropertyName extends PropertyNames<PluginSettings>>(\n    propertyName: PropertyName,\n    value: PluginSettings[PropertyName]\n  ): Promise<string> {\n    this.ensureLoaded();\n    await this.edit((settings) => {\n      settings[propertyName] = value;\n    });\n    return this.currentState.validationMessages[propertyName];\n  }\n\n  /**\n   * Validates the settings.\n   *\n   * @param settings - The settings.\n   * @returns A {@link Promise} that resolves to the validation result.\n   */\n  public async validate(settings: PluginSettings): Promise<ValidationResult<PluginSettings>> {\n    const result: ValidationResult<PluginSettings> = {};\n    for (const [propertyName, validator] of this.validators) {\n      const validationMessage = await validator(settings[propertyName], settings);\n      if (validationMessage) {\n        result[propertyName] = validationMessage;\n      }\n    }\n\n    return result;\n  }\n\n  /**\n   * Gets the transformer.\n   *\n   * @returns The transformer.\n   */\n  protected getTransformer(): Transformer {\n    return defaultTransformer;\n  }\n\n  /**\n   * Called when the plugin settings record is loaded from disk.\n   *\n   * @param record - The record.\n   */\n  protected async onLoadRecord(record: GenericObject): Promise<void> {\n    for (const converter of this.legacySettingsConverters) {\n      converter(record);\n    }\n    await noopAsync();\n  }\n\n  /**\n   * Called when settings are loaded or reloaded.\n   *\n   * @param _loadedState - The loaded settings state.\n   * @param _isInitialLoad - Whether this is the initial load.\n   */\n  protected async onLoadSettings(\n    _loadedState: ReadonlyPluginSettingsState<PluginSettings>,\n    _isInitialLoad: boolean\n  ): Promise<void> {\n    await noopAsync();\n  }\n\n  /**\n   * Called when settings are saved.\n   *\n   * @param params - The parameters.\n   */\n  protected async onSaveSettings(params: PluginSettingsComponentBaseOnSaveSettingsParams<PluginSettings>): Promise<void> {\n    const {\n      context: _context,\n      newState: _newState,\n      oldState: _oldState\n    } = params;\n    await noopAsync();\n  }\n\n  /**\n   * Called when the plugin settings record is about to be saved to disk.\n   *\n   * @param _record - The record.\n   */\n  protected async onSavingRecord(_record: GenericObject): Promise<void> {\n    await noopAsync();\n  }\n\n  /**\n   * Registers the legacy settings converters.\n   * Override to register legacy settings converters.\n   */\n  protected registerLegacySettingsConverters(): void {\n    noop();\n  }\n\n  /**\n   * Registers the validators.\n   * Override to register validators for properties.\n   */\n  protected registerValidators(): void {\n    noop();\n  }\n\n  private async cloneSettings(settings: PluginSettings): Promise<PluginSettings> {\n    const record = await this.settingsToRawRecord(settings);\n    const json = JSON.stringify(record);\n    const cloneRecord = JSON.parse(json) as GenericObject;\n    return await this.rawRecordToSettings(cloneRecord);\n  }\n\n  private async cloneState(\n    state: PluginSettingsState<PluginSettings>\n  ): Promise<PluginSettingsState<PluginSettings>> {\n    return {\n      effectiveValues: await this.cloneSettings(state.effectiveValues),\n      inputValues: await this.cloneSettings(state.inputValues),\n      validationMessages: { ...state.validationMessages }\n    };\n  }\n\n  private createDefaultState(): PluginSettingsState<PluginSettings> {\n    return {\n      effectiveValues: new this.pluginSettingsClass(),\n      inputValues: new this.pluginSettingsClass(),\n      validationMessages: castTo<Record<PropertyNames<PluginSettings>, string>>({})\n    };\n  }\n\n  private async edit(settingsEditor: (settings: PluginSettings) => Promisable<void>): Promise<void> {\n    try {\n      await settingsEditor(this.currentState.inputValues);\n    } finally {\n      const validationResult = await this.validate(this.currentState.inputValues);\n      for (const propertyName of this.propertyNames) {\n        const validationMessage = validationResult[propertyName] ?? '';\n        this.currentState.validationMessages[propertyName] = validationMessage;\n        const defaults = this.defaultSettings as PluginSettings;\n        this.currentState.effectiveValues[propertyName] = validationMessage\n          ? defaults[propertyName]\n          : this.currentState.inputValues[propertyName];\n      }\n    }\n  }\n\n  private isValidPropertyName(property: unknown): property is PropertyNames<PluginSettings> {\n    if (typeof property !== 'string') {\n      return false;\n    }\n\n    return (this.propertyNames as string[]).includes(property);\n  }\n\n  private async rawRecordToSettings(rawRecord: GenericObject): Promise<PluginSettings> {\n    rawRecord = this.getTransformer().transformObjectRecursively(rawRecord);\n    await this.onLoadRecord(rawRecord);\n\n    const settings = new this.pluginSettingsClass();\n    const defaults = this.defaultSettings as PluginSettings;\n\n    for (const [propertyName, value] of Object.entries(rawRecord)) {\n      if (!this.isValidPropertyName(propertyName)) {\n        getLibDebugger('PluginSettingsComponentBase:rawRecordToSettings')(`Unknown property: ${propertyName}`);\n        continue;\n      }\n\n      if (typeof value !== typeof defaults[propertyName]) {\n        getLibDebugger('PluginSettingsComponentBase:rawRecordToSettings')(\n          'Possible invalid value type. It might lead to an unexpected behavior of the plugin. There is also a chance it is a false-negative warning, as we are unable to determine the exact type of the value in runtime.',\n          {\n            defaultValue: defaults[propertyName],\n            propertyName,\n            value\n          }\n        );\n      }\n\n      settings[propertyName] = value as PropertyValues<PluginSettings>;\n    }\n\n    return settings;\n  }\n\n  private async saveToFileImpl(): Promise<void> {\n    await this.dataHandler.saveData(await this.settingsToRawRecord(this.currentState.inputValues));\n  }\n\n  private setPropertyImpl(params: PluginSettingsComponentBaseSetPropertyImplParams<PluginSettings>): void {\n    const {\n      propertyName,\n      validationMessage,\n      value\n    } = params;\n    const defaults = this.defaultSettings as PluginSettings;\n    this.currentState.inputValues[propertyName] = value;\n    this.currentState.validationMessages[propertyName] = validationMessage ?? '';\n    this.currentState.effectiveValues[propertyName] = validationMessage ? defaults[propertyName] : value;\n  }\n\n  private async settingsToRawRecord(settings: PluginSettings): Promise<GenericObject> {\n    const rawRecord: GenericObject = {};\n\n    for (const propertyName of this.propertyNames) {\n      rawRecord[propertyName] = settings[propertyName];\n    }\n\n    await this.onSavingRecord(rawRecord);\n\n    return this.getTransformer().transformObjectRecursively(rawRecord);\n  }\n}\n"],
  "mappings": "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",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../../src/obsidian/components/plugin-settings-component.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Component that manages plugin settings: data, persistence, validation, and events.\n *\n * This is the single public-facing settings API for plugin authors.\n * All settings logic (load, save, validate, transform, clone) is handled directly\n * by this component \u2014 no separate manager class is needed.\n */\n\nimport type {\n  Constructor,\n  Promisable,\n  ReadonlyDeep\n} from 'type-fest';\n\nimport type {\n  AsyncEventRef,\n  AsyncEventSource\n} from '../../async-events.ts';\nimport type { Transformer } from '../../transformers/transformer.ts';\nimport type { GenericObject } from '../../type-guards.ts';\nimport type {\n  MaybeReturn,\n  StringKeys\n} from '../../type.ts';\nimport type { DataHandler } from '../data-handler.ts';\nimport type { PluginEventSource } from '../plugin/plugin-event-source.ts';\n\nimport { AsyncEvents } from '../../async-events.ts';\nimport { getLibDebugger } from '../../debug.ts';\nimport {\n  noop,\n  noopAsync\n} from '../../function.ts';\nimport {\n  castTo,\n  getAllKeys,\n  isDeepEqual\n} from '../../object-utils.ts';\nimport { DateTransformer } from '../../transformers/date-transformer.ts';\nimport { DurationTransformer } from '../../transformers/duration-transformer.ts';\nimport { GroupTransformer } from '../../transformers/group-transformer.ts';\nimport { MapTransformer } from '../../transformers/map-transformer.ts';\nimport { SetTransformer } from '../../transformers/set-transformer.ts';\nimport { SkipPrivatePropertyTransformer } from '../../transformers/skip-private-property-transformer.ts';\nimport { TwoWayMapTransformer } from '../../transformers/two-way-map-transformer.ts';\nimport { ValueWrapper } from '../../value-wrapper.ts';\nimport { registerAsyncEvent } from './async-events-component.ts';\nimport { ComponentEx } from './component-ex.ts';\n\nconst defaultTransformer = new GroupTransformer([\n  new SkipPrivatePropertyTransformer(),\n  new DateTransformer(),\n  new DurationTransformer(),\n  new MapTransformer(),\n  new SetTransformer(),\n  new TwoWayMapTransformer()\n]);\n\n/**\n * Constructor parameters for {@link PluginSettingsComponentBase}.\n *\n * @typeParam PluginSettings - The type of the plugin settings.\n */\nexport interface PluginSettingsComponentBaseConstructorParams<PluginSettings> {\n  /**\n   * The data handler for the plugin.\n   */\n  readonly dataHandler: DataHandler;\n\n  /**\n   * The plugin events.\n   */\n  readonly pluginEventSource: PluginEventSource;\n\n  /**\n   * The plugin settings class.\n   */\n  readonly pluginSettingsClass: Constructor<PluginSettings, []>;\n}\n\n/**\n * Parameters for {@link PluginSettingsComponentBase.onSaveSettings}.\n *\n * @typeParam PluginSettings - The type of the plugin settings.\n */\nexport interface PluginSettingsComponentBaseOnSaveSettingsParams<PluginSettings extends object> {\n  /**\n   * The save context.\n   */\n  readonly context: unknown;\n\n  /**\n   * The new settings state.\n   */\n  readonly newState: ReadonlyPluginSettingsState<PluginSettings>;\n\n  /**\n   * The old settings state.\n   */\n  readonly oldState: ReadonlyPluginSettingsState<PluginSettings>;\n}\n\n/**\n * A snapshot of plugin settings state, including raw input values, effective (validated) values,\n * and per-property validation messages.\n *\n * @typeParam PluginSettings - The type of the plugin settings.\n */\nexport interface PluginSettingsState<PluginSettings extends object> {\n  /**\n   * The effective settings values used by the plugin. Invalid properties are replaced with defaults.\n   */\n  effectiveValues: PluginSettings;\n\n  /**\n   * The raw input values as entered by the user. May contain invalid values.\n   */\n  inputValues: PluginSettings;\n\n  /**\n   * Per-property validation messages. Empty string means valid.\n   */\n  validationMessages: Record<StringKeys<PluginSettings>, string>;\n}\n\n/**\n * Readonly version of {@link PluginSettings}.\n *\n * @typeParam PluginSettings - The type of the plugin settings.\n */\nexport type ReadonlyPluginSettings<PluginSettings extends object> = ReadonlyDeep<PluginSettings>;\n\n/**\n * Readonly version of {@link PluginSettingsState} for use in event callbacks and public getters.\n *\n * @typeParam PluginSettings - The type of the plugin settings.\n */\nexport type ReadonlyPluginSettingsState<PluginSettings extends object> = ReadonlyDeep<PluginSettingsState<PluginSettings>>;\n\n/**\n * A validator function for a settings property.\n *\n * @typeParam PluginSettings - The plugin settings type.\n * @typeParam PropertyName - The property name.\n */\nexport type SettingsValidator<PluginSettings extends object, PropertyName extends StringKeys<PluginSettings> = StringKeys<PluginSettings>> = (\n  value: PluginSettings[PropertyName],\n  settings: PluginSettings\n) => Promisable<MaybeReturn<string>>;\n\ninterface PluginSettingsComponentBaseEventMap<PluginSettings extends object> {\n  loadSettings: [\n    loadedState: ReadonlyPluginSettingsState<PluginSettings>,\n    isInitialLoad: boolean\n  ];\n  saveSettings: [\n    newState: ReadonlyPluginSettingsState<PluginSettings>,\n    oldState: ReadonlyPluginSettingsState<PluginSettings>,\n    context: unknown\n  ];\n}\n\n/**\n * Parameters for {@link PluginSettingsComponentBase.setPropertyImpl}.\n *\n * @typeParam PluginSettings - The type of the plugin settings.\n */\ninterface PluginSettingsComponentBaseSetPropertyImplParams<PluginSettings extends object> {\n  /**\n   * The name of the property to set.\n   */\n  readonly propertyName: PropertyNames<PluginSettings>;\n\n  /**\n   * The validation message. Empty or unset means valid.\n   */\n  readonly validationMessage?: string | undefined;\n\n  /**\n   * The value to set.\n   */\n  readonly value: PropertyValues<PluginSettings>;\n}\n\ntype PropertyNames<PluginSettings extends object> = StringKeys<PluginSettings>;\n\ntype PropertyValues<PluginSettings extends object> = PluginSettings[PropertyNames<PluginSettings>];\n\ntype ValidationResult<PluginSettings extends object> = Partial<Record<StringKeys<PluginSettings>, string>>;\n\n/**\n * Base class for plugin settings components.\n *\n * Manages settings data, persistence, validation, and events.\n * Plugin authors extend this class and implement {@link createDefaultSettings}.\n *\n * @typeParam PluginSettings - The plugin settings type.\n */\n// eslint-disable-next-line obsidian-dev-utils/require-component-suffix -- Non-abstract base class; consumers extend it.\nexport class PluginSettingsComponentBase<PluginSettings extends object> extends ComponentEx implements AsyncEventSource<PluginSettingsComponentBaseEventMap<PluginSettings>> {\n  /**\n   * Gets the readonly default settings.\n   *\n   * @returns The default settings (as a readonly object).\n   */\n  public readonly defaultSettings: ReadonlyDeep<PluginSettings>;\n\n  /**\n   * Gets the readonly effective settings (validated, with defaults substituted for invalid values).\n   *\n   * @returns The readonly effective settings.\n   */\n  public get settings(): ReadonlyDeep<PluginSettings> {\n    return this.settingsState.effectiveValues;\n  }\n\n  /**\n   * Gets the current settings state snapshot.\n   *\n   * @returns The current settings state.\n   */\n  public get settingsState(): ReadonlyPluginSettingsState<PluginSettings> {\n    return this.currentState as ReadonlyPluginSettingsState<PluginSettings>;\n  }\n\n  /**\n   * The data handler used to load and save the plugin settings.\n   */\n  protected readonly dataHandler: DataHandler;\n  /**\n   * The plugin event source the component listens to for external settings changes.\n   */\n  protected readonly pluginEventSource: PluginEventSource;\n\n  /**\n   * The plugin settings class used to construct settings instances.\n   */\n  protected readonly pluginSettingsClass: Constructor<PluginSettings, []>;\n  private readonly asyncEvents = new AsyncEvents<PluginSettingsComponentBaseEventMap<PluginSettings>>();\n  private currentState: PluginSettingsState<PluginSettings>;\n\n  private lastSavedState: PluginSettingsState<PluginSettings>;\n\n  private readonly legacySettingsConverters: ((record: GenericObject) => void)[] = [];\n  private readonly propertyNames: PropertyNames<PluginSettings>[];\n\n  private readonly validators = new Map<PropertyNames<PluginSettings>, SettingsValidator<PluginSettings>>();\n\n  /**\n   * Creates a new plugin settings component.\n   *\n   * @param params - The constructor parameters.\n   */\n  public constructor(params: PluginSettingsComponentBaseConstructorParams<PluginSettings>) {\n    super();\n    this.dataHandler = params.dataHandler;\n    this.pluginSettingsClass = params.pluginSettingsClass;\n    this.pluginEventSource = params.pluginEventSource;\n\n    this.defaultSettings = new this.pluginSettingsClass() as ReadonlyDeep<PluginSettings>;\n    this.currentState = this.createDefaultState();\n    this.lastSavedState = this.createDefaultState();\n    this.propertyNames = getAllKeys(this.currentState.inputValues);\n    this.registerValidators();\n    this.registerLegacySettingsConverters();\n  }\n\n  /**\n   * Edits the plugin settings and saves them.\n   *\n   * @param settingsEditor - The editor.\n   * @param context - The context.\n   * @returns A {@link Promise} that resolves when the settings are saved.\n   */\n  public async editAndSave(settingsEditor: (settings: PluginSettings) => Promisable<void>, context?: unknown): Promise<void> {\n    this.ensureLoaded();\n    await this.edit(settingsEditor);\n    await this.saveToFile(context);\n  }\n\n  /**\n   * Ensures the settings are safe.\n   *\n   * It runs validation for each property and sets the default value if the validation fails.\n   *\n   * @param settings - The settings.\n   * @returns A {@link Promise} that resolves when the settings are safe.\n   */\n  public async ensureSafe(settings: PluginSettings): Promise<void> {\n    const validationResult = await this.validate(settings);\n    const defaults = this.defaultSettings as PluginSettings;\n    for (const propertyName of this.propertyNames) {\n      // eslint-disable-next-line unicorn/no-computed-property-existence-check -- This tests whether a validation message is non-empty, not whether the key exists.\n      if (validationResult[propertyName]) {\n        settings[propertyName] = defaults[propertyName];\n      }\n    }\n  }\n\n  /**\n   * Gets a safe copy of the settings.\n   *\n   * @param settings - The settings.\n   * @returns A {@link Promise} that resolves to the safe copy of the settings.\n   */\n  public async getSafeCopy(settings: PluginSettings): Promise<PluginSettings> {\n    const safeSettings = await this.cloneSettings(settings);\n    await this.ensureSafe(safeSettings);\n    return safeSettings;\n  }\n\n  /**\n   * Loads the plugin settings from the file.\n   *\n   * @param isInitialLoad - Whether the settings are being loaded for the first time.\n   * @returns A {@link Promise} that resolves when the settings are loaded.\n   */\n  public async loadFromFile(isInitialLoad: boolean): Promise<void> {\n    this.ensureLoaded();\n    const data = await this.dataHandler.loadData();\n    this.lastSavedState = this.createDefaultState();\n    this.currentState = this.createDefaultState();\n\n    try {\n      if (data === undefined || data === null) {\n        return;\n      }\n\n      if (typeof data !== 'object') {\n        console.error(`Invalid settings from data.json. Expected Object, got: ${typeof data}`);\n        return;\n      }\n\n      const rawRecord = data as GenericObject;\n      const parsedSettings = await this.rawRecordToSettings(rawRecord);\n      const validationResult = await this.validate(parsedSettings);\n\n      for (const propertyName of this.propertyNames) {\n        this.setPropertyImpl({\n          propertyName,\n          validationMessage: validationResult[propertyName],\n          value: parsedSettings[propertyName]\n        });\n      }\n\n      this.lastSavedState = await this.cloneState(this.currentState);\n\n      // A component that knows no property names cannot normalize anything: `settingsToRawRecord()` can\n      // Only ever return `{}`, so the save below would not rewrite `data.json` -- it would empty it.\n      // `PluginBase` adds a placeholder `PluginSettingsComponentBase<object>` before `onloadImpl()` swaps\n      // In the plugin's own component, and that placeholder is exactly this case: it read every real\n      // Setting, kept none of them, and saved the difference back over the file.\n      if (this.propertyNames.length === 0) {\n        return;\n      }\n\n      const newRecord = await this.settingsToRawRecord(this.currentState.inputValues);\n\n      if (!isDeepEqual(newRecord, data)) {\n        await this.saveToFileImpl();\n      }\n    } finally {\n      await this.asyncEvents.triggerAsync('loadSettings', this.currentState as ReadonlyPluginSettingsState<PluginSettings>, isInitialLoad);\n    }\n  }\n\n  /**\n   * Remove an event listener.\n   *\n   * @typeParam EventName - The name of the event.\n   * @typeParam Arguments - The types of the arguments the event callback accepts.\n   * @param name - The name of the event.\n   * @param callback - The callback to remove.\n   */\n  public off<\n    EventName extends keyof PluginSettingsComponentBaseEventMap<PluginSettings>,\n    // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters -- We need to use the dummy parameter to get type inference.\n    Arguments extends EventName extends keyof PluginSettingsComponentBaseEventMap<PluginSettings> ? PluginSettingsComponentBaseEventMap<PluginSettings>[EventName]\n      : unknown[]\n  >(name: EventName, callback: (...$arguments: Arguments) => Promisable<void>): void {\n    this.asyncEvents.off(name, callback);\n  }\n\n  /**\n   * Remove an event listener by reference.\n   *\n   * @param eventRef - The reference to the event listener.\n   */\n  public offref(eventRef: AsyncEventRef): void {\n    this.asyncEvents.offref(eventRef);\n  }\n\n  /**\n   * Add an event listener.\n   *\n   * @typeParam EventName - The name of the event.\n   * @typeParam Arguments - The types of the arguments the event callback accepts.\n   * @param name - The name of the event.\n   * @param callback - The callback to call when the event is triggered.\n   * @param thisArgument - The context passed as `this` to the `callback`.\n   * @returns A reference to the event listener.\n   *\n   * @remarks Not refactored to parameter-object pattern, to keep the parity with {@link obsidian#Events#on} (or once, correspondingly).\n   */\n  public on<\n    EventName extends keyof PluginSettingsComponentBaseEventMap<PluginSettings>,\n    // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters -- We need to use the dummy parameter to get type inference.\n    Arguments extends EventName extends keyof PluginSettingsComponentBaseEventMap<PluginSettings> ? PluginSettingsComponentBaseEventMap<PluginSettings>[EventName]\n      : unknown[]\n  >(name: EventName, callback: (...$arguments: Arguments) => Promisable<void>, thisArgument?: unknown): AsyncEventRef {\n    return this.asyncEvents.on(name, callback, thisArgument);\n  }\n\n  /**\n   * Trigger an event, executing all the listeners in order even if some of them throw an error.\n   *\n   * Add an event listener that will be called only once.\n   *\n   * @typeParam EventName - The name of the event.\n   * @typeParam Arguments - The types of the arguments the event callback accepts.\n   * @param name - The name of the event.\n   * @param callback - The callback to call when the event is triggered.\n   * @param thisArgument - The context passed as `this` to the `callback`.\n   * @returns A reference to the event listener.\n   *\n   * @remarks Not refactored to parameter-object pattern, to keep the parity with {@link obsidian#Events#on} (or once, correspondingly).\n   */\n  public once<\n    EventName extends keyof PluginSettingsComponentBaseEventMap<PluginSettings>,\n    // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters -- We need to use the dummy parameter to get type inference.\n    Arguments extends EventName extends keyof PluginSettingsComponentBaseEventMap<PluginSettings> ? PluginSettingsComponentBaseEventMap<PluginSettings>[EventName]\n      : unknown[]\n  >(name: EventName, callback: (...$arguments: Arguments) => Promisable<void>, thisArgument?: unknown): AsyncEventRef {\n    return this.asyncEvents.once(name, callback, thisArgument);\n  }\n\n  /**\n   * Called when the external settings change.\n   *\n   * @returns A {@link Promise} that resolves when the settings are reloaded.\n   */\n  public async onExternalSettingsChange(): Promise<void> {\n    this.ensureLoaded();\n    await this.loadFromFile(false);\n  }\n\n  /**\n   * Loads settings from file and registers event handlers.\n   */\n  public override async onloadAsync(): Promise<void> {\n    registerAsyncEvent(this, this.on('loadSettings', this.onLoadSettings.bind(this)));\n    registerAsyncEvent(this, this.on('saveSettings', (newState, oldState, context) => this.onSaveSettings({ context, newState, oldState })));\n    registerAsyncEvent(this, this.pluginEventSource.on('externalSettingsChange', this.onExternalSettingsChange.bind(this)));\n    await this.loadFromFile(true);\n  }\n\n  /**\n   * Registers a legacy settings converter.\n   *\n   * @typeParam LegacySettings - The legacy settings class.\n   * @param legacySettingsClass - The legacy settings class.\n   * @param converter - The converter.\n   */\n  public registerLegacySettingsConverter<LegacySettings extends object>(\n    legacySettingsClass: new () => LegacySettings,\n    converter: (legacySettings: Partial<LegacySettings> & Partial<PluginSettings>) => void\n  ): void {\n    const thisWrapper = ValueWrapper.of(this);\n    this.legacySettingsConverters.push(legacySettingsConverter);\n\n    function legacySettingsConverter(record: GenericObject): void {\n      const legacySettingsKeys = new Set<string>(Object.keys(new legacySettingsClass()));\n      const pluginSettingKeys = new Set<string>(thisWrapper.value.propertyNames);\n      const legacySettings = record as Partial<LegacySettings> & Partial<PluginSettings>;\n      converter(legacySettings);\n      for (const key of Object.keys(legacySettings)) {\n        if (pluginSettingKeys.has(key)) {\n          continue;\n        }\n\n        if (!legacySettingsKeys.has(key)) {\n          continue;\n        }\n\n        // eslint-disable-next-line @typescript-eslint/no-dynamic-delete -- We have no other way to delete the property.\n        delete record[key];\n      }\n    }\n  }\n\n  /**\n   * Registers a validator for a property.\n   *\n   * @typeParam PropertyName - The name of the settings property.\n   * @param propertyName - The name of the property.\n   * @param validator - The validator.\n   */\n  public registerValidator<PropertyName extends PropertyNames<PluginSettings>>(\n    propertyName: PropertyName,\n    validator: SettingsValidator<PluginSettings, PropertyName>\n  ): void {\n    this.validators.set(propertyName, validator as SettingsValidator<PluginSettings>);\n  }\n\n  /**\n   * Revalidates the settings.\n   *\n   * @returns The validation messages.\n   */\n  public async revalidate(): Promise<Record<PropertyNames<PluginSettings>, string>> {\n    this.ensureLoaded();\n    await this.edit(noop);\n    return this.currentState.validationMessages;\n  }\n\n  /**\n   * Saves the new plugin settings.\n   *\n   * @param context - The context of the save to file operation.\n   * @returns A {@link Promise} that resolves when the settings are saved.\n   */\n  public async saveToFile(context?: unknown): Promise<void> {\n    this.ensureLoaded();\n    if (isDeepEqual(this.lastSavedState.inputValues, this.currentState.inputValues)) {\n      return;\n    }\n\n    await this.saveToFileImpl();\n    await this.asyncEvents.triggerAsync(\n      'saveSettings',\n      this.currentState as ReadonlyPluginSettingsState<PluginSettings>,\n      this.lastSavedState as ReadonlyPluginSettingsState<PluginSettings>,\n      context\n    );\n    this.lastSavedState = await this.cloneState(this.currentState);\n  }\n\n  /**\n   * Sets the value of a property.\n   *\n   * @typeParam PropertyName - The name of the property.\n   * @param propertyName - The name of the property.\n   * @param value - The value to set.\n   * @returns A {@link Promise} that resolves to the validation message.\n   */\n  public async setProperty<PropertyName extends PropertyNames<PluginSettings>>(\n    propertyName: PropertyName,\n    value: PluginSettings[PropertyName]\n  ): Promise<string> {\n    this.ensureLoaded();\n    await this.edit((settings) => {\n      settings[propertyName] = value;\n    });\n    return this.currentState.validationMessages[propertyName];\n  }\n\n  /**\n   * Validates the settings.\n   *\n   * @param settings - The settings.\n   * @returns A {@link Promise} that resolves to the validation result.\n   */\n  public async validate(settings: PluginSettings): Promise<ValidationResult<PluginSettings>> {\n    const result: ValidationResult<PluginSettings> = {};\n    for (const [propertyName, validator] of this.validators) {\n      const validationMessage = await validator(settings[propertyName], settings);\n      if (validationMessage) {\n        result[propertyName] = validationMessage;\n      }\n    }\n\n    return result;\n  }\n\n  /**\n   * Gets the transformer.\n   *\n   * @returns The transformer.\n   */\n  protected getTransformer(): Transformer {\n    return defaultTransformer;\n  }\n\n  /**\n   * Called when the plugin settings record is loaded from disk.\n   *\n   * @param record - The record.\n   */\n  protected async onLoadRecord(record: GenericObject): Promise<void> {\n    for (const converter of this.legacySettingsConverters) {\n      converter(record);\n    }\n    await noopAsync();\n  }\n\n  /**\n   * Called when settings are loaded or reloaded.\n   *\n   * @param _loadedState - The loaded settings state.\n   * @param _isInitialLoad - Whether this is the initial load.\n   */\n  protected async onLoadSettings(\n    _loadedState: ReadonlyPluginSettingsState<PluginSettings>,\n    _isInitialLoad: boolean\n  ): Promise<void> {\n    await noopAsync();\n  }\n\n  /**\n   * Called when settings are saved.\n   *\n   * @param params - The parameters.\n   */\n  protected async onSaveSettings(params: PluginSettingsComponentBaseOnSaveSettingsParams<PluginSettings>): Promise<void> {\n    const {\n      context: _context,\n      newState: _newState,\n      oldState: _oldState\n    } = params;\n    await noopAsync();\n  }\n\n  /**\n   * Called when the plugin settings record is about to be saved to disk.\n   *\n   * @param _record - The record.\n   */\n  protected async onSavingRecord(_record: GenericObject): Promise<void> {\n    await noopAsync();\n  }\n\n  /**\n   * Registers the legacy settings converters.\n   * Override to register legacy settings converters.\n   */\n  protected registerLegacySettingsConverters(): void {\n    noop();\n  }\n\n  /**\n   * Registers the validators.\n   * Override to register validators for properties.\n   */\n  protected registerValidators(): void {\n    noop();\n  }\n\n  private async cloneSettings(settings: PluginSettings): Promise<PluginSettings> {\n    const record = await this.settingsToRawRecord(settings);\n    const json = JSON.stringify(record);\n    const cloneRecord = JSON.parse(json) as GenericObject;\n    return await this.rawRecordToSettings(cloneRecord);\n  }\n\n  private async cloneState(\n    state: PluginSettingsState<PluginSettings>\n  ): Promise<PluginSettingsState<PluginSettings>> {\n    return {\n      effectiveValues: await this.cloneSettings(state.effectiveValues),\n      inputValues: await this.cloneSettings(state.inputValues),\n      validationMessages: { ...state.validationMessages }\n    };\n  }\n\n  private createDefaultState(): PluginSettingsState<PluginSettings> {\n    return {\n      effectiveValues: new this.pluginSettingsClass(),\n      inputValues: new this.pluginSettingsClass(),\n      validationMessages: castTo<Record<PropertyNames<PluginSettings>, string>>({})\n    };\n  }\n\n  private async edit(settingsEditor: (settings: PluginSettings) => Promisable<void>): Promise<void> {\n    try {\n      await settingsEditor(this.currentState.inputValues);\n    } finally {\n      const validationResult = await this.validate(this.currentState.inputValues);\n      for (const propertyName of this.propertyNames) {\n        const validationMessage = validationResult[propertyName] ?? '';\n        this.currentState.validationMessages[propertyName] = validationMessage;\n        const defaults = this.defaultSettings as PluginSettings;\n        this.currentState.effectiveValues[propertyName] = validationMessage\n          ? defaults[propertyName]\n          : this.currentState.inputValues[propertyName];\n      }\n    }\n  }\n\n  private isValidPropertyName(property: unknown): property is PropertyNames<PluginSettings> {\n    if (typeof property !== 'string') {\n      return false;\n    }\n\n    return (this.propertyNames as string[]).includes(property);\n  }\n\n  private async rawRecordToSettings(rawRecord: GenericObject): Promise<PluginSettings> {\n    rawRecord = this.getTransformer().transformObjectRecursively(rawRecord);\n    await this.onLoadRecord(rawRecord);\n\n    const settings = new this.pluginSettingsClass();\n    const defaults = this.defaultSettings as PluginSettings;\n\n    for (const [propertyName, value] of Object.entries(rawRecord)) {\n      if (!this.isValidPropertyName(propertyName)) {\n        getLibDebugger('PluginSettingsComponentBase:rawRecordToSettings')(`Unknown property: ${propertyName}`);\n        continue;\n      }\n\n      if (typeof value !== typeof defaults[propertyName]) {\n        getLibDebugger('PluginSettingsComponentBase:rawRecordToSettings')(\n          'Possible invalid value type. It might lead to an unexpected behavior of the plugin. There is also a chance it is a false-negative warning, as we are unable to determine the exact type of the value in runtime.',\n          {\n            defaultValue: defaults[propertyName],\n            propertyName,\n            value\n          }\n        );\n      }\n\n      settings[propertyName] = value as PropertyValues<PluginSettings>;\n    }\n\n    return settings;\n  }\n\n  private async saveToFileImpl(): Promise<void> {\n    await this.dataHandler.saveData(await this.settingsToRawRecord(this.currentState.inputValues));\n  }\n\n  private setPropertyImpl(params: PluginSettingsComponentBaseSetPropertyImplParams<PluginSettings>): void {\n    const {\n      propertyName,\n      validationMessage,\n      value\n    } = params;\n    const defaults = this.defaultSettings as PluginSettings;\n    this.currentState.inputValues[propertyName] = value;\n    this.currentState.validationMessages[propertyName] = validationMessage ?? '';\n    this.currentState.effectiveValues[propertyName] = validationMessage ? defaults[propertyName] : value;\n  }\n\n  private async settingsToRawRecord(settings: PluginSettings): Promise<GenericObject> {\n    const rawRecord: GenericObject = {};\n\n    for (const propertyName of this.propertyNames) {\n      rawRecord[propertyName] = settings[propertyName];\n    }\n\n    await this.onSavingRecord(rawRecord);\n\n    return this.getTransformer().transformObjectRecursively(rawRecord);\n  }\n}\n"],
  "mappings": "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",
  "names": []
}


package/dist/lib/esm/obsidian/index.d.mts

@@ -3,6 +3,7 @@ export * as 'active-file-provider' from './active-file-provider.mjs';
 export * as 'app' from './app.mjs';
 export * as 'async-with-notice' from './async-with-notice.mjs';
 export * as 'attachment-path' from './attachment-path.mjs';
+export * as 'attachment-unit-folder' from './attachment-unit-folder.mjs';
 export * as 'backlink' from './backlink.mjs';
 export * as 'bases-view-registrar' from './bases-view-registrar.mjs';
 export * as 'callout' from './callout.mjs';