obsidian-dev-utils 24.1.1 → 24.2.1-beta.1

package/dist/lib/esm/obsidian/Plugin/PluginSettingsManagerBase.mjs

@@ -9,7 +9,10 @@ import {
   noop,
   noopAsync
 } from "../../Function.mjs";
-import { getAllKeys } from "../../Object.mjs";
+import {
+  deepEqual,
+  getAllKeys
+} from "../../Object.mjs";
 import { DateTransformer } from "../../Transformers/DateTransformer.mjs";
 import { DurationTransformer } from "../../Transformers/DurationTransformer.mjs";
 import { GroupTransformer } from "../../Transformers/GroupTransformer.mjs";
@@ -19,59 +22,6 @@ const defaultTransformer = new GroupTransformer([
   new DateTransformer(),
   new DurationTransformer()
 ]);
-class ProxyHandlerBase {
-  constructor(properties) {
-    this.properties = properties;
-  }
-  get(target, prop) {
-    const record = target;
-    if (typeof prop !== "string") {
-      return record[prop];
-    }
-    const property = this.properties.get(prop);
-    if (!property) {
-      return record[prop];
-    }
-    return this.getPropertyValue(property);
-  }
-}
-class EditableSettingsProxyHandler extends ProxyHandlerBase {
-  validationPromise = Promise.resolve();
-  set(target, prop, value) {
-    const record = target;
-    record[prop] = value;
-    if (typeof prop !== "string") {
-      return true;
-    }
-    const property = this.properties.get(prop);
-    if (!property) {
-      return true;
-    }
-    property.setValue(value);
-    this.validationPromise = this.validationPromise.then(() => property.validate());
-    return true;
-  }
-  getPropertyValue(property) {
-    return property.currentValue;
-  }
-}
-class PropertiesMap extends Map {
-  getTyped(propertyName) {
-    const property = super.get(propertyName);
-    if (!property) {
-      throw new Error(`Property ${String(propertyName)} not found`);
-    }
-    return property;
-  }
-  setTyped(propertyName, value) {
-    return super.set(propertyName, value);
-  }
-}
-class SafeSettingsProxyHandler extends ProxyHandlerBase {
-  getPropertyValue(property) {
-    return property.safeValue;
-  }
-}
 class PluginSettingsManagerBase {
   /**
    * Creates a new plugin settings manager.
@@ -81,50 +31,63 @@ class PluginSettingsManagerBase {
   constructor(plugin) {
     this.plugin = plugin;
     this.app = plugin.app;
-    this.currentSettings = this.createDefaultSettings();
+    this.defaultSettings = this.createDefaultSettings();
+    this.currentSettingsWrapper = this.createDefaultSettingsWrapper();
+    this.lastSavedSettingsWrapper = this.createDefaultSettingsWrapper();
+    this.propertyNames = getAllKeys(this.currentSettingsWrapper.settings);
     this.registerValidators();
-    this.properties = new PropertiesMap();
-    const record = this.currentSettings;
-    for (const propertyName of getAllKeys(this.currentSettings)) {
-      let propertySetter2 = function(value) {
-        record[propertyName] = value;
-      };
-      var propertySetter = propertySetter2;
-      this.properties.set(
-        propertyName,
-        new PluginSettingsProperty(propertyName, this.currentSettings[propertyName], this.validators.get(propertyName) ?? noop, propertySetter2)
-      );
-    }
-    this.validators.clear();
-    this.safeSettings = new Proxy(this.currentSettings, new SafeSettingsProxyHandler(this.properties));
   }
   app;
-  safeSettings;
-  currentSettings;
-  properties;
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  defaultSettings;
+  /**
+   * Gets the current settings wrapper.
+   *
+   * @returns The current settings wrapper.
+   */
+  get settingsWrapper() {
+    return this.currentSettingsWrapper;
+  }
+  currentSettingsWrapper;
+  lastSavedSettingsWrapper;
+  propertyNames;
   validators = /* @__PURE__ */ new Map();
   /**
    * Edits the plugin settings and saves them.
    *
-   * @param editor - The editor.
+   * @param settingsEditor - The editor.
    * @param context - The context.
    * @returns A {@link Promise} that resolves when the settings are saved.
    */
-  async editAndSave(editor, context) {
-    const editableSettings = new Proxy(this.currentSettings, new EditableSettingsProxyHandler(this.properties));
-    await editor(editableSettings);
-    await editableSettings.validationPromise;
+  async editAndSave(settingsEditor, context) {
+    await this.edit(settingsEditor);
     await this.saveToFile(context);
   }
   /**
-   * Gets a property of the plugin settings.
+   * Ensures the settings are safe.
    *
-   * @param propertyName - The name of the property.
-   * @returns The property.
+   * It runs validation for each property and sets the default value if the validation fails.
+   *
+   * @param settings - The settings.
+   * @returns A {@link Promise} that resolves when the settings are safe.
    */
-  getProperty(propertyName) {
-    return this.properties.getTyped(propertyName);
+  async ensureSafe(settings) {
+    const validationResult = await this.validate(settings);
+    for (const propertyName of this.propertyNames) {
+      if (validationResult[propertyName]) {
+        settings[propertyName] = this.defaultSettings[propertyName];
+      }
+    }
+  }
+  /**
+   * Gets a safe copy of the settings.
+   *
+   * @param settings - The settings.
+   * @returns A {@link Promise} that resolves to the safe copy of the settings.
+   */
+  async getSafeCopy(settings) {
+    const safeSettings = this.cloneSettings(settings);
+    await this.ensureSafe(safeSettings);
+    return safeSettings;
   }
   /**
    * Loads the plugin settings from the file.
@@ -133,51 +96,28 @@ class PluginSettingsManagerBase {
    * @returns A {@link Promise} that resolves when the settings are loaded.
    */
   async loadFromFile(isInitialLoad) {
-    for (const property of this.properties.values()) {
-      property.reset();
-    }
     const data = await this.plugin.loadData();
+    this.lastSavedSettingsWrapper = this.createDefaultSettingsWrapper();
+    this.currentSettingsWrapper = this.createDefaultSettingsWrapper();
     if (data === void 0 || data === null) {
       return;
     }
-    if (typeof data !== "object" || Array.isArray(data)) {
-      const type = Array.isArray(data) ? "Array" : typeof data;
-      console.error(`Invalid data type. Expected Object, got: ${type}`);
+    if (typeof data !== "object") {
+      console.error(`Invalid settings from data.json. Expected Object, got: ${typeof data}`);
       return;
     }
-    let record = data;
-    const originalJson = JSON.stringify(record);
-    record = this.getTransformer().transformObjectRecursively(record);
-    await this.onLoadRecord(record);
-    const propertiesToSave = [];
-    for (const [propertyName, value] of Object.entries(record)) {
-      const property = this.properties.get(propertyName);
-      if (!property) {
-        console.warn(`Unknown property: ${propertyName}`);
-        continue;
-      }
-      if (typeof value !== typeof property.defaultValue) {
-        console.warn(
-          "Possible invalid value type read from config file. 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.",
-          {
-            defaultValue: property.defaultValue,
-            propertyName,
-            value
-          }
-        );
-      }
-      property.setValue(value);
-      propertiesToSave.push(property);
-    }
-    for (const property of propertiesToSave) {
-      await property.validate();
-      property.save();
+    const rawRecord = data;
+    const parsedSettings = await this.rawRecordToSettings(rawRecord);
+    const validationResult = await this.validate(parsedSettings);
+    for (const propertyName of this.propertyNames) {
+      this.setPropertyImpl(propertyName, parsedSettings[propertyName], validationResult[propertyName]);
     }
-    const newJson = JSON.stringify(await this.prepareRecordToSave());
-    if (newJson !== originalJson) {
+    this.lastSavedSettingsWrapper = this.cloneSettingsWrapper(this.currentSettingsWrapper);
+    const newRecord = await this.settingsToRawRecord(this.currentSettingsWrapper.settings);
+    if (!deepEqual(newRecord, data)) {
       await this.saveToFileImpl();
     }
-    await this.plugin.onLoadSettings(this.getSavedSettings(), isInitialLoad);
+    await this.plugin.onLoadSettings(this.currentSettingsWrapper, isInitialLoad);
   }
   /**
    * Saves the new plugin settings.
@@ -186,16 +126,42 @@ class PluginSettingsManagerBase {
    * @returns A {@link Promise} that resolves when the settings are saved.
    */
   async saveToFile(context) {
-    const oldSettings = this.getSavedSettings();
-    let hasChanges = false;
-    for (const property of this.properties.values()) {
-      hasChanges ||= property.save();
-    }
-    if (!hasChanges) {
+    if (deepEqual(this.lastSavedSettingsWrapper.settings, this.currentSettingsWrapper.settings)) {
       return;
     }
     await this.saveToFileImpl();
-    await this.plugin.onSaveSettings(this.getSavedSettings(), oldSettings, context);
+    await this.plugin.onSaveSettings(this.currentSettingsWrapper, this.lastSavedSettingsWrapper, context);
+    this.lastSavedSettingsWrapper = this.cloneSettingsWrapper(this.currentSettingsWrapper);
+  }
+  /**
+   * Sets the value of a property.
+   *
+   * @typeParam PropertyName - The name of the property.
+   * @param propertyName - The name of the property.
+   * @param value - The value to set.
+   * @returns A {@link Promise} that resolves to the validation message.
+   */
+  async setProperty(propertyName, value) {
+    await this.edit((settings) => {
+      settings[propertyName] = value;
+    });
+    return this.currentSettingsWrapper.validationMessages[propertyName];
+  }
+  /**
+   * Validates the settings.
+   *
+   * @param settings - The settings.
+   * @returns A {@link Promise} that resolves to the validation result.
+   */
+  async validate(settings) {
+    const result = {};
+    for (const [propertyName, validator] of this.validators.entries()) {
+      const validationMessage = await validator(settings[propertyName], settings);
+      if (validationMessage) {
+        result[propertyName] = validationMessage;
+      }
+    }
+    return result;
   }
   /**
    * Gets the transformer.
@@ -238,147 +204,84 @@ class PluginSettingsManagerBase {
   registerValidators() {
     noop();
   }
-  getSavedSettings() {
-    const savedSettings = {};
-    for (const [propertyName, property] of this.properties.entries()) {
-      savedSettings[propertyName] = property.lastSavedValue;
-    }
-    const proto = Object.getPrototypeOf(this.currentSettings);
-    Object.setPrototypeOf(savedSettings, proto);
-    return savedSettings;
-  }
-  async prepareRecordToSave() {
-    const settings = {};
-    for (const [propertyName, property] of this.properties.entries()) {
-      settings[propertyName] = property.currentValue;
-    }
-    await this.onSavingRecord(settings);
-    return this.getTransformer().transformObjectRecursively(settings);
-  }
-  async saveToFileImpl() {
-    await this.plugin.saveData(await this.prepareRecordToSave());
-  }
-}
-class PluginSettingsProperty {
-  /**
-   * Creates a new plugin settings property.
-   *
-   * @param propertyName - The name of the property.
-   * @param defaultValue - The default value of the property.
-   * @param validator - The validator of the property.
-   * @param propertySetter - The property setter of the property.
-   */
-  constructor(propertyName, defaultValue, validator, propertySetter) {
-    this.propertyName = propertyName;
-    this.defaultValue = defaultValue;
-    this.validator = validator;
-    this.propertySetter = propertySetter;
-    this._lastSavedValue = defaultValue;
-    this._currentValue = defaultValue;
-  }
-  /**
-   * The current value of the property.
-   *
-   * @returns The current value.
-   */
-  get currentValue() {
-    return this._currentValue;
-  }
-  /**
-   * The last saved value of the property.
-   *
-   * @returns The last saved value.
-   */
-  get lastSavedValue() {
-    return this._lastSavedValue;
+  cloneSettings(settings) {
+    const record = this.settingsToRawRecord(settings);
+    const json = JSON.stringify(record);
+    const cloneRecord = JSON.parse(json);
+    return this.rawRecordToSettings(cloneRecord);
   }
-  /**
-   * The safe value of the property.
-   *
-   * @returns The safe value.
-   */
-  get safeValue() {
-    return this._validationMessage ? this.defaultValue : this._currentValue;
+  cloneSettingsWrapper(settingsWrapper) {
+    return {
+      safeSettings: this.cloneSettings(settingsWrapper.safeSettings),
+      settings: this.cloneSettings(settingsWrapper.settings),
+      validationMessages: { ...settingsWrapper.validationMessages }
+    };
   }
-  /**
-   * The validation message of the property.
-   *
-   * @returns The validation message.
-   */
-  get validationMessage() {
-    return this._validationMessage;
+  createDefaultSettingsWrapper() {
+    return {
+      safeSettings: this.createDefaultSettings(),
+      settings: this.createDefaultSettings(),
+      validationMessages: {}
+    };
   }
-  _currentValue;
-  _lastSavedValue;
-  _validationMessage = "";
-  /**
-   * Resets the current value of the property to the default value.
-   */
-  reset() {
-    this._currentValue = this.defaultValue;
-    this._validationMessage = "";
+  async edit(settingsEditor) {
+    try {
+      await settingsEditor(this.currentSettingsWrapper.settings);
+    } finally {
+      const validationResult = await this.validate(this.currentSettingsWrapper.settings);
+      for (const propertyName of this.propertyNames) {
+        const validationMessage = validationResult[propertyName] ?? "";
+        this.currentSettingsWrapper.validationMessages[propertyName] = validationMessage;
+        this.currentSettingsWrapper.safeSettings[propertyName] = validationMessage ? this.defaultSettings[propertyName] : this.currentSettingsWrapper.settings[propertyName];
+      }
+    }
   }
-  /**
-   * Saves the current value of the property.
-   *
-   * @returns `true` if the value was changed, `false` otherwise.
-   */
-  save() {
-    if (this._lastSavedValue === this._currentValue) {
+  isValidPropertyName(prop) {
+    if (typeof prop !== "string") {
       return false;
     }
-    this._lastSavedValue = this._currentValue;
-    return true;
+    return this.propertyNames.includes(prop);
   }
-  /**
-   * Sets the validation message of the property.
-   *
-   * @param validationMessage - The validation message.
-   */
-  setValidationMessage(validationMessage) {
-    this._validationMessage = validationMessage;
-    this.showWarning();
+  async rawRecordToSettings(rawRecord) {
+    await this.onLoadRecord(rawRecord);
+    const settings = this.createDefaultSettings();
+    for (const [propertyName, value] of Object.entries(rawRecord)) {
+      if (!this.isValidPropertyName(propertyName)) {
+        console.warn(`Unknown property: ${propertyName}`);
+        continue;
+      }
+      if (typeof value !== typeof this.defaultSettings[propertyName]) {
+        console.warn(
+          "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.",
+          {
+            defaultValue: this.defaultSettings[propertyName],
+            propertyName,
+            value
+          }
+        );
+      }
+      settings[propertyName] = value;
+    }
+    return settings;
   }
-  /**
-   * Sets the current value of the property.
-   *
-   * @param value - The value to set.
-   */
-  setValue(value) {
-    this._currentValue = value;
-    this.propertySetter(value);
+  async saveToFileImpl() {
+    await this.plugin.saveData(await this.settingsToRawRecord(this.currentSettingsWrapper));
   }
-  /**
-   * Validates the current value of the property.
-   *
-   * @returns A {@link Promise} that resolves when the validation is complete.
-   */
-  async validate() {
-    try {
-      this._validationMessage = await this.validator(this._currentValue) ?? "";
-    } catch (error) {
-      console.error("Validation failed", {
-        propertyName: this.propertyName,
-        value: this._currentValue
-      }, error);
-      this._validationMessage = "Validation failed";
-    }
-    this.showWarning(this._currentValue);
+  setPropertyImpl(propertyName, value, validationMessage) {
+    this.currentSettingsWrapper.settings[propertyName] = value;
+    this.currentSettingsWrapper.validationMessages[propertyName] = validationMessage ?? "";
+    this.currentSettingsWrapper.safeSettings[propertyName] = validationMessage ? this.defaultSettings[propertyName] : value;
   }
-  showWarning(value) {
-    if (!this._validationMessage) {
-      return;
+  async settingsToRawRecord(settings) {
+    const rawRecord = {};
+    for (const propertyName of this.propertyNames) {
+      rawRecord[propertyName] = settings[propertyName];
     }
-    console.warn(`Could not set plugin setting: ${this.propertyName}. Using default value instead.`, {
-      defaultValue: this.defaultValue,
-      propertyName: this.propertyName,
-      validationMessage: this._validationMessage,
-      value
-    });
+    await this.onSavingRecord(rawRecord);
+    return this.getTransformer().transformObjectRecursively(rawRecord);
   }
 }
 export {
-  PluginSettingsManagerBase,
-  PluginSettingsProperty
+  PluginSettingsManagerBase
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../../src/obsidian/Plugin/PluginSettingsManagerBase.ts"],
  "sourcesContent": ["/**\n * @packageDocumentation\n *\n * Plugin settings manager base class.\n */\n\nimport type { App } from 'obsidian';\nimport type {\n  Promisable,\n  ReadonlyDeep\n} from 'type-fest';\n\nimport type { Transformer } from '../../Transformers/Transformer.ts';\nimport type {\n  MaybeReturn,\n  StringKeys\n} from '../../Type.ts';\nimport type {\n  ExtractPlugin,\n  ExtractPluginSettings,\n  PluginTypesBase\n} from './PluginTypesBase.ts';\n\nimport {\n  noop,\n  noopAsync\n} from '../../Function.ts';\nimport { getAllKeys } from '../../Object.ts';\nimport { DateTransformer } from '../../Transformers/DateTransformer.ts';\nimport { DurationTransformer } from '../../Transformers/DurationTransformer.ts';\nimport { GroupTransformer } from '../../Transformers/GroupTransformer.ts';\nimport { SkipPrivatePropertyTransformer } from '../../Transformers/SkipPrivatePropertyTransformer.ts';\n\nconst defaultTransformer = new GroupTransformer([\n  new SkipPrivatePropertyTransformer(),\n  new DateTransformer(),\n  new DurationTransformer()\n]);\n\ntype PropertySetter = (value: unknown) => void;\n\ntype Validator<T> = (value: T) => Promisable<MaybeReturn<string>>;\n\nabstract class ProxyHandlerBase<PluginSettings extends object> implements ProxyHandler<PluginSettings> {\n  public constructor(protected readonly properties: PropertiesMap<PluginSettings>) {}\n\n  public get(target: PluginSettings, prop: string | symbol): unknown {\n    const record = target as Record<string | symbol, unknown>;\n    if (typeof prop !== 'string') {\n      return record[prop];\n    }\n\n    const property = this.properties.get(prop);\n    if (!property) {\n      return record[prop];\n    }\n\n    return this.getPropertyValue(property);\n  }\n\n  protected abstract getPropertyValue(property: PluginSettingsProperty<unknown>): unknown;\n}\n\nclass EditableSettingsProxyHandler<PluginSettings extends object> extends ProxyHandlerBase<PluginSettings> {\n  private validationPromise = Promise.resolve();\n  public set(target: PluginSettings, prop: string | symbol, value: unknown): boolean {\n    const record = target as Record<string | symbol, unknown>;\n    record[prop] = value;\n\n    if (typeof prop !== 'string') {\n      return true;\n    }\n\n    const property = this.properties.get(prop);\n    if (!property) {\n      return true;\n    }\n\n    property.setValue(value);\n    this.validationPromise = this.validationPromise.then(() => property.validate());\n    return true;\n  }\n\n  protected override getPropertyValue(property: PluginSettingsProperty<unknown>): unknown {\n    return property.currentValue;\n  }\n}\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nclass PropertiesMap<PluginSettings extends object> extends Map<string, PluginSettingsProperty<any>> {\n  public getTyped<PropertyName extends StringKeys<PluginSettings>>(propertyName: PropertyName): PluginSettingsProperty<PluginSettings[PropertyName]> {\n    const property = super.get(propertyName);\n    if (!property) {\n      throw new Error(`Property ${String(propertyName)} not found`);\n    }\n\n    return property as PluginSettingsProperty<PluginSettings[PropertyName]>;\n  }\n\n  public setTyped<PropertyName extends StringKeys<PluginSettings>>(\n    propertyName: PropertyName,\n    value: PluginSettingsProperty<PluginSettings[PropertyName]>\n  ): this {\n    return super.set(propertyName, value);\n  }\n}\n\nclass SafeSettingsProxyHandler<PluginSettings extends object> extends ProxyHandlerBase<PluginSettings> {\n  protected override getPropertyValue(property: PluginSettingsProperty<unknown>): unknown {\n    return property.safeValue;\n  }\n}\n\n/**\n * Base class for managing plugin settings.\n *\n * @typeParam PluginTypes - Plugin-specific types.\n */\nexport abstract class PluginSettingsManagerBase<PluginTypes extends PluginTypesBase> {\n  public readonly app: App;\n  public readonly safeSettings: ReadonlyDeep<ExtractPluginSettings<PluginTypes>>;\n\n  private readonly currentSettings: ExtractPluginSettings<PluginTypes>;\n  private readonly properties: PropertiesMap<ExtractPluginSettings<PluginTypes>>;\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  private readonly validators: Map<string, Validator<any>> = new Map<string, Validator<any>>();\n\n  /**\n   * Creates a new plugin settings manager.\n   *\n   * @param plugin - The plugin.\n   */\n  public constructor(public readonly plugin: ExtractPlugin<PluginTypes>) {\n    this.app = plugin.app;\n    this.currentSettings = this.createDefaultSettings();\n\n    this.registerValidators();\n\n    this.properties = new PropertiesMap<ExtractPluginSettings<PluginTypes>>();\n\n    const record = this.currentSettings as Record<string, unknown>;\n\n    for (const propertyName of getAllKeys(this.currentSettings)) {\n      function propertySetter(value: unknown): void {\n        record[propertyName] = value;\n      }\n\n      this.properties.set(\n        propertyName,\n        new PluginSettingsProperty(propertyName, this.currentSettings[propertyName], this.validators.get(propertyName) ?? noop, propertySetter)\n      );\n    }\n\n    this.validators.clear();\n\n    this.safeSettings = new Proxy(this.currentSettings, new SafeSettingsProxyHandler<ExtractPluginSettings<PluginTypes>>(this.properties)) as ReadonlyDeep<\n      ExtractPluginSettings<PluginTypes>\n    >;\n  }\n\n  /**\n   * Edits the plugin settings and saves them.\n   *\n   * @param editor - The editor.\n   * @param context - The context.\n   * @returns A {@link Promise} that resolves when the settings are saved.\n   */\n  public async editAndSave(editor: (settings: ExtractPluginSettings<PluginTypes>) => Promisable<void>, context?: unknown): Promise<void> {\n    const editableSettings = new Proxy(this.currentSettings, new EditableSettingsProxyHandler<ExtractPluginSettings<PluginTypes>>(this.properties)) as {\n      validationPromise: Promise<void>;\n    } & ExtractPluginSettings<PluginTypes>;\n    await editor(editableSettings);\n    await editableSettings.validationPromise;\n    await this.saveToFile(context);\n  }\n\n  /**\n   * Gets a property of the plugin settings.\n   *\n   * @param propertyName - The name of the property.\n   * @returns The property.\n   */\n  public getProperty<PropertyName extends StringKeys<ExtractPluginSettings<PluginTypes>>>(\n    propertyName: PropertyName\n  ): PluginSettingsProperty<ExtractPluginSettings<PluginTypes>[PropertyName]> {\n    return this.properties.getTyped(propertyName);\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    for (const property of this.properties.values()) {\n      property.reset();\n    }\n\n    const data = await this.plugin.loadData() as unknown;\n\n    if (data === undefined || data === null) {\n      return;\n    }\n\n    if (typeof data !== 'object' || Array.isArray(data)) {\n      const type = Array.isArray(data) ? 'Array' : typeof data;\n      console.error(`Invalid data type. Expected Object, got: ${type}`);\n      return;\n    }\n\n    let record = data as Record<string, unknown>;\n    const originalJson = JSON.stringify(record);\n    record = this.getTransformer().transformObjectRecursively(record);\n    await this.onLoadRecord(record);\n\n    const propertiesToSave: PluginSettingsProperty<unknown>[] = [];\n\n    for (const [propertyName, value] of Object.entries(record)) {\n      const property = this.properties.get(propertyName);\n      if (!property) {\n        console.warn(`Unknown property: ${propertyName}`);\n        continue;\n      }\n\n      if (typeof value !== typeof property.defaultValue) {\n        console.warn(\n          'Possible invalid value type read from config file. 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: property.defaultValue as unknown,\n            propertyName,\n            value\n          }\n        );\n      }\n\n      property.setValue(value);\n      propertiesToSave.push(property);\n    }\n\n    for (const property of propertiesToSave) {\n      await property.validate();\n      property.save();\n    }\n\n    const newJson = JSON.stringify(await this.prepareRecordToSave());\n\n    if (newJson !== originalJson) {\n      await this.saveToFileImpl();\n    }\n\n    await this.plugin.onLoadSettings(this.getSavedSettings(), isInitialLoad);\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    const oldSettings = this.getSavedSettings();\n\n    let hasChanges = false;\n\n    for (const property of this.properties.values()) {\n      hasChanges ||= property.save();\n    }\n\n    if (!hasChanges) {\n      return;\n    }\n\n    await this.saveToFileImpl();\n    await this.plugin.onSaveSettings(this.getSavedSettings(), oldSettings, context);\n  }\n\n  protected abstract createDefaultSettings(): ExtractPluginSettings<PluginTypes>;\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 are loaded.\n   *\n   * @param _record - The record.\n   */\n  protected async onLoadRecord(_record: Record<string, unknown>): Promise<void> {\n    await noopAsync();\n  }\n\n  /**\n   * Called when the plugin settings are saving.\n   *\n   * @param _record - The record.\n   */\n  protected async onSavingRecord(_record: Record<string, unknown>): Promise<void> {\n    await noopAsync();\n  }\n\n  /**\n   * Registers a validator for a property.\n   *\n   * @param propertyName - The name of the property.\n   * @param validator - The validator.\n   */\n  protected registerValidator<PropertyName extends StringKeys<ExtractPluginSettings<PluginTypes>>>(\n    propertyName: PropertyName,\n    validator: Validator<ExtractPluginSettings<PluginTypes>[PropertyName]>\n  ): void {\n    this.validators.set(propertyName, validator);\n  }\n\n  /**\n   * Registers the validators.\n   *\n   * This method can be overridden by subclasses to register validators for properties.\n   */\n  protected registerValidators(): void {\n    noop();\n  }\n\n  private getSavedSettings(): ExtractPluginSettings<PluginTypes> {\n    const savedSettings: Record<string, unknown> = {};\n    for (const [propertyName, property] of this.properties.entries()) {\n      savedSettings[propertyName] = property.lastSavedValue as\n        | ExtractPluginSettings<PluginTypes>[StringKeys<ExtractPluginSettings<PluginTypes>>]\n        | undefined;\n    }\n    const proto = Object.getPrototypeOf(this.currentSettings) as object;\n    Object.setPrototypeOf(savedSettings, proto);\n\n    return savedSettings as ExtractPluginSettings<PluginTypes>;\n  }\n\n  private async prepareRecordToSave(): Promise<Record<string, unknown>> {\n    const settings: Record<string, unknown> = {};\n    for (const [propertyName, property] of this.properties.entries()) {\n      settings[propertyName] = property.currentValue as unknown;\n    }\n\n    await this.onSavingRecord(settings);\n\n    return this.getTransformer().transformObjectRecursively(settings);\n  }\n\n  private async saveToFileImpl(): Promise<void> {\n    await this.plugin.saveData(await this.prepareRecordToSave());\n  }\n}\n\n/**\n * A property of a plugin settings.\n *\n * @typeParam T - The type of the property.\n */\nexport class PluginSettingsProperty<T> {\n  /**\n   * The current value of the property.\n   *\n   * @returns The current value.\n   */\n  public get currentValue(): T {\n    return this._currentValue;\n  }\n\n  /**\n   * The last saved value of the property.\n   *\n   * @returns The last saved value.\n   */\n  public get lastSavedValue(): T {\n    return this._lastSavedValue;\n  }\n\n  /**\n   * The safe value of the property.\n   *\n   * @returns The safe value.\n   */\n  public get safeValue(): T {\n    return this._validationMessage ? this.defaultValue : this._currentValue;\n  }\n\n  /**\n   * The validation message of the property.\n   *\n   * @returns The validation message.\n   */\n  public get validationMessage(): string {\n    return this._validationMessage;\n  }\n\n  private _currentValue: T;\n\n  private _lastSavedValue: T;\n\n  private _validationMessage = '';\n\n  /**\n   * Creates a new plugin settings property.\n   *\n   * @param propertyName - The name of the property.\n   * @param defaultValue - The default value of the property.\n   * @param validator - The validator of the property.\n   * @param propertySetter - The property setter of the property.\n   */\n  public constructor(\n    private readonly propertyName: string,\n    public readonly defaultValue: T,\n    private readonly validator: Validator<T>,\n    private readonly propertySetter: PropertySetter\n  ) {\n    this._lastSavedValue = defaultValue;\n    this._currentValue = defaultValue;\n  }\n\n  /**\n   * Resets the current value of the property to the default value.\n   */\n  public reset(): void {\n    this._currentValue = this.defaultValue;\n    this._validationMessage = '';\n  }\n\n  /**\n   * Saves the current value of the property.\n   *\n   * @returns `true` if the value was changed, `false` otherwise.\n   */\n  public save(): boolean {\n    if (this._lastSavedValue === this._currentValue) {\n      return false;\n    }\n\n    this._lastSavedValue = this._currentValue;\n    return true;\n  }\n\n  /**\n   * Sets the validation message of the property.\n   *\n   * @param validationMessage - The validation message.\n   */\n  public setValidationMessage(validationMessage: string): void {\n    this._validationMessage = validationMessage;\n    this.showWarning();\n  }\n\n  /**\n   * Sets the current value of the property.\n   *\n   * @param value - The value to set.\n   */\n  public setValue(value: T): void {\n    this._currentValue = value;\n    this.propertySetter(value);\n  }\n\n  /**\n   * Validates the current value of the property.\n   *\n   * @returns A {@link Promise} that resolves when the validation is complete.\n   */\n  public async validate(): Promise<void> {\n    try {\n      this._validationMessage = (await this.validator(this._currentValue) as string | undefined) ?? '';\n    } catch (error) {\n      console.error('Validation failed', {\n        propertyName: this.propertyName,\n        value: this._currentValue\n      }, error);\n      this._validationMessage = 'Validation failed';\n    }\n    this.showWarning(this._currentValue);\n  }\n\n  private showWarning(value?: T): void {\n    if (!this._validationMessage) {\n      return;\n    }\n\n    console.warn(`Could not set plugin setting: ${this.propertyName}. Using default value instead.`, {\n      defaultValue: this.defaultValue,\n      propertyName: this.propertyName,\n      validationMessage: this._validationMessage,\n      value\n    });\n  }\n}\n"],
  "mappings": "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",
  "names": ["propertySetter"]
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../../src/obsidian/Plugin/PluginSettingsManagerBase.ts"],
  "sourcesContent": ["/**\n * @packageDocumentation\n *\n * Plugin settings manager base class.\n */\n\nimport type { App } from 'obsidian';\nimport type {\n  Promisable,\n  ReadonlyDeep\n} from 'type-fest';\n\nimport type { GenericObject } from '../../Object.ts';\nimport type { Transformer } from '../../Transformers/Transformer.ts';\nimport type {\n  MaybeReturn,\n  StringKeys\n} from '../../Type.ts';\nimport type { PluginSettingsWrapper } from './PluginSettingsWrapper.ts';\nimport type {\n  ExtractPlugin,\n  ExtractPluginSettings,\n  ExtractPluginSettingsPropertyNames,\n  ExtractPluginSettingsPropertyValues,\n  ExtractPluginSettingsWrapper,\n  ExtractReadonlyPluginSettingsWrapper,\n  PluginTypesBase\n} from './PluginTypesBase.ts';\n\nimport {\n  noop,\n  noopAsync\n} from '../../Function.ts';\nimport {\n  deepEqual,\n  getAllKeys\n} from '../../Object.ts';\nimport { DateTransformer } from '../../Transformers/DateTransformer.ts';\nimport { DurationTransformer } from '../../Transformers/DurationTransformer.ts';\nimport { GroupTransformer } from '../../Transformers/GroupTransformer.ts';\nimport { SkipPrivatePropertyTransformer } from '../../Transformers/SkipPrivatePropertyTransformer.ts';\n\nconst defaultTransformer = new GroupTransformer([\n  new SkipPrivatePropertyTransformer(),\n  new DateTransformer(),\n  new DurationTransformer()\n]);\n\ntype ValidationResult<PluginSettings extends object> = Partial<Record<StringKeys<PluginSettings>, string>>;\n\ntype Validator<PluginSettings extends object, PropertyName extends StringKeys<PluginSettings> = StringKeys<PluginSettings>> = (\n  value: PluginSettings[PropertyName],\n  settings: PluginSettings\n) => Promisable<MaybeReturn<string>>;\n\n/**\n * Base class for managing plugin settings.\n *\n * @typeParam PluginTypes - Plugin-specific types.\n */\nexport abstract class PluginSettingsManagerBase<PluginTypes extends PluginTypesBase> {\n  public readonly app: App;\n\n  public readonly defaultSettings: ReadonlyDeep<ExtractPluginSettings<PluginTypes>>;\n\n  /**\n   * Gets the current settings wrapper.\n   *\n   * @returns The current settings wrapper.\n   */\n  public get settingsWrapper(): ExtractReadonlyPluginSettingsWrapper<PluginTypes> {\n    return this.currentSettingsWrapper as ExtractReadonlyPluginSettingsWrapper<PluginTypes>;\n  }\n\n  private currentSettingsWrapper: ExtractPluginSettingsWrapper<PluginTypes>;\n\n  private lastSavedSettingsWrapper: ExtractPluginSettingsWrapper<PluginTypes>;\n  private readonly propertyNames: ExtractPluginSettingsPropertyNames<PluginTypes>[];\n  private readonly validators = new Map<ExtractPluginSettingsPropertyNames<PluginTypes>, Validator<ExtractPluginSettings<PluginTypes>>>();\n  /**\n   * Creates a new plugin settings manager.\n   *\n   * @param plugin - The plugin.\n   */\n  public constructor(public readonly plugin: ExtractPlugin<PluginTypes>) {\n    this.app = plugin.app;\n    this.defaultSettings = this.createDefaultSettings() as ReadonlyDeep<ExtractPluginSettings<PluginTypes>>;\n    this.currentSettingsWrapper = this.createDefaultSettingsWrapper();\n    this.lastSavedSettingsWrapper = this.createDefaultSettingsWrapper();\n    this.propertyNames = getAllKeys(this.currentSettingsWrapper.settings);\n    this.registerValidators();\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: ExtractPluginSettings<PluginTypes>) => Promisable<void>, context?: unknown): Promise<void> {\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: ExtractPluginSettings<PluginTypes>): Promise<void> {\n    const validationResult = await this.validate(settings);\n    for (const propertyName of this.propertyNames) {\n      if (validationResult[propertyName]) {\n        settings[propertyName] = this.defaultSettings[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: ExtractPluginSettings<PluginTypes>): Promise<ExtractPluginSettings<PluginTypes>> {\n    const safeSettings = 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    const data = await this.plugin.loadData() as unknown;\n    this.lastSavedSettingsWrapper = this.createDefaultSettingsWrapper();\n    this.currentSettingsWrapper = this.createDefaultSettingsWrapper();\n\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(propertyName, parsedSettings[propertyName], validationResult[propertyName]);\n    }\n\n    this.lastSavedSettingsWrapper = this.cloneSettingsWrapper(this.currentSettingsWrapper);\n\n    const newRecord = await this.settingsToRawRecord(this.currentSettingsWrapper.settings);\n\n    if (!deepEqual(newRecord, data)) {\n      await this.saveToFileImpl();\n    }\n\n    await this.plugin.onLoadSettings(this.currentSettingsWrapper, isInitialLoad);\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    if (deepEqual(this.lastSavedSettingsWrapper.settings, this.currentSettingsWrapper.settings)) {\n      return;\n    }\n\n    await this.saveToFileImpl();\n    await this.plugin.onSaveSettings(this.currentSettingsWrapper, this.lastSavedSettingsWrapper, context);\n    this.lastSavedSettingsWrapper = this.cloneSettingsWrapper(this.currentSettingsWrapper);\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 ExtractPluginSettingsPropertyNames<PluginTypes>>(\n    propertyName: PropertyName,\n    value: ExtractPluginSettings<PluginTypes>[PropertyName]\n  ): Promise<string> {\n    await this.edit((settings) => {\n      settings[propertyName] = value;\n    });\n    return this.currentSettingsWrapper.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: ExtractPluginSettings<PluginTypes>): Promise<ValidationResult<ExtractPluginSettings<PluginTypes>>> {\n    const result: ValidationResult<ExtractPluginSettings<PluginTypes>> = {};\n    for (const [propertyName, validator] of this.validators.entries()) {\n      const validationMessage = await validator(settings[propertyName], settings);\n      if (validationMessage) {\n        result[propertyName] = validationMessage;\n      }\n    }\n\n    return result;\n  }\n\n  protected abstract createDefaultSettings(): ExtractPluginSettings<PluginTypes>;\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 are loaded.\n   *\n   * @param _record - The record.\n   */\n  protected async onLoadRecord(_record: GenericObject): Promise<void> {\n    await noopAsync();\n  }\n\n  /**\n   * Called when the plugin settings are saving.\n   *\n   * @param _record - The record.\n   */\n  protected async onSavingRecord(_record: GenericObject): Promise<void> {\n    await noopAsync();\n  }\n\n  /**\n   * Registers a validator for a property.\n   *\n   * @param propertyName - The name of the property.\n   * @param validator - The validator.\n   */\n  protected registerValidator<PropertyName extends ExtractPluginSettingsPropertyNames<PluginTypes>>(\n    propertyName: PropertyName,\n    validator: Validator<ExtractPluginSettings<PluginTypes>, PropertyName>\n  ): void {\n    this.validators.set(propertyName, validator as Validator<ExtractPluginSettings<PluginTypes>>);\n  }\n\n  /**\n   * Registers the validators.\n   *\n   * This method can be overridden by subclasses to register validators for properties.\n   */\n  protected registerValidators(): void {\n    noop();\n  }\n\n  private cloneSettings(settings: ExtractPluginSettings<PluginTypes>): ExtractPluginSettings<PluginTypes> {\n    const record = this.settingsToRawRecord(settings);\n    const json = JSON.stringify(record);\n    const cloneRecord = JSON.parse(json) as GenericObject;\n    return this.rawRecordToSettings(cloneRecord);\n  }\n\n  private cloneSettingsWrapper(\n    settingsWrapper: PluginSettingsWrapper<ExtractPluginSettings<PluginTypes>>\n  ): PluginSettingsWrapper<ExtractPluginSettings<PluginTypes>> {\n    return {\n      safeSettings: this.cloneSettings(settingsWrapper.safeSettings),\n      settings: this.cloneSettings(settingsWrapper.settings),\n      validationMessages: { ...settingsWrapper.validationMessages }\n    };\n  }\n\n  private createDefaultSettingsWrapper(): PluginSettingsWrapper<ExtractPluginSettings<PluginTypes>> {\n    return {\n      safeSettings: this.createDefaultSettings(),\n      settings: this.createDefaultSettings(),\n      validationMessages: {} as Record<ExtractPluginSettingsPropertyNames<PluginTypes>, string>\n    };\n  }\n\n  private async edit(settingsEditor: (settings: ExtractPluginSettings<PluginTypes>) => Promisable<void>): Promise<void> {\n    try {\n      await settingsEditor(this.currentSettingsWrapper.settings);\n    } finally {\n      const validationResult = await this.validate(this.currentSettingsWrapper.settings);\n      for (const propertyName of this.propertyNames) {\n        const validationMessage = validationResult[propertyName] ?? '';\n        this.currentSettingsWrapper.validationMessages[propertyName] = validationMessage;\n        this.currentSettingsWrapper.safeSettings[propertyName] = validationMessage\n          ? this.defaultSettings[propertyName]\n          : this.currentSettingsWrapper.settings[propertyName];\n      }\n    }\n  }\n\n  private isValidPropertyName(prop: unknown): prop is ExtractPluginSettingsPropertyNames<PluginTypes> {\n    if (typeof prop !== 'string') {\n      return false;\n    }\n\n    return (this.propertyNames as string[]).includes(prop);\n  }\n\n  private async rawRecordToSettings(rawRecord: GenericObject): Promise<ExtractPluginSettings<PluginTypes>> {\n    await this.onLoadRecord(rawRecord);\n\n    const settings = this.createDefaultSettings();\n\n    for (const [propertyName, value] of Object.entries(rawRecord)) {\n      if (!this.isValidPropertyName(propertyName)) {\n        console.warn(`Unknown property: ${propertyName}`);\n        continue;\n      }\n\n      if (typeof value !== typeof this.defaultSettings[propertyName]) {\n        console.warn(\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: this.defaultSettings[propertyName],\n            propertyName,\n            value\n          }\n        );\n      }\n\n      settings[propertyName] = value as ExtractPluginSettingsPropertyValues<PluginTypes>;\n    }\n\n    return settings;\n  }\n\n  private async saveToFileImpl(): Promise<void> {\n    await this.plugin.saveData(await this.settingsToRawRecord(this.currentSettingsWrapper));\n  }\n\n  private setPropertyImpl(\n    propertyName: ExtractPluginSettingsPropertyNames<PluginTypes>,\n    value: ExtractPluginSettingsPropertyValues<PluginTypes>,\n    validationMessage?: string\n  ): void {\n    this.currentSettingsWrapper.settings[propertyName] = value;\n    this.currentSettingsWrapper.validationMessages[propertyName] = validationMessage ?? '';\n    this.currentSettingsWrapper.safeSettings[propertyName] = validationMessage ? this.defaultSettings[propertyName] : value;\n  }\n\n  private async settingsToRawRecord(settings: ExtractPluginSettings<PluginTypes>): 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": ";;;;;;;AA6BA;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP,SAAS,uBAAuB;AAChC,SAAS,2BAA2B;AACpC,SAAS,wBAAwB;AACjC,SAAS,sCAAsC;AAE/C,MAAM,qBAAqB,IAAI,iBAAiB;AAAA,EAC9C,IAAI,+BAA+B;AAAA,EACnC,IAAI,gBAAgB;AAAA,EACpB,IAAI,oBAAoB;AAC1B,CAAC;AAcM,MAAe,0BAA+D;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAwB5E,YAA4B,QAAoC;AAApC;AACjC,SAAK,MAAM,OAAO;AAClB,SAAK,kBAAkB,KAAK,sBAAsB;AAClD,SAAK,yBAAyB,KAAK,6BAA6B;AAChE,SAAK,2BAA2B,KAAK,6BAA6B;AAClE,SAAK,gBAAgB,WAAW,KAAK,uBAAuB,QAAQ;AACpE,SAAK,mBAAmB;AAAA,EAC1B;AAAA,EA9BgB;AAAA,EAEA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOhB,IAAW,kBAAqE;AAC9E,WAAO,KAAK;AAAA,EACd;AAAA,EAEQ;AAAA,EAEA;AAAA,EACS;AAAA,EACA,aAAa,oBAAI,IAAoG;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAsBtI,MAAa,YAAY,gBAAoF,SAAkC;AAC7I,UAAM,KAAK,KAAK,cAAc;AAC9B,UAAM,KAAK,WAAW,OAAO;AAAA,EAC/B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAUA,MAAa,WAAW,UAA6D;AACnF,UAAM,mBAAmB,MAAM,KAAK,SAAS,QAAQ;AACrD,eAAW,gBAAgB,KAAK,eAAe;AAC7C,UAAI,iBAAiB,YAAY,GAAG;AAClC,iBAAS,YAAY,IAAI,KAAK,gBAAgB,YAAY;AAAA,MAC5D;AAAA,IACF;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,MAAa,YAAY,UAA2F;AAClH,UAAM,eAAe,KAAK,cAAc,QAAQ;AAChD,UAAM,KAAK,WAAW,YAAY;AAClC,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,MAAa,aAAa,eAAuC;AAC/D,UAAM,OAAO,MAAM,KAAK,OAAO,SAAS;AACxC,SAAK,2BAA2B,KAAK,6BAA6B;AAClE,SAAK,yBAAyB,KAAK,6BAA6B;AAEhE,QAAI,SAAS,UAAa,SAAS,MAAM;AACvC;AAAA,IACF;AAEA,QAAI,OAAO,SAAS,UAAU;AAC5B,cAAQ,MAAM,0DAA0D,OAAO,IAAI,EAAE;AACrF;AAAA,IACF;AAEA,UAAM,YAAY;AAClB,UAAM,iBAAiB,MAAM,KAAK,oBAAoB,SAAS;AAC/D,UAAM,mBAAmB,MAAM,KAAK,SAAS,cAAc;AAE3D,eAAW,gBAAgB,KAAK,eAAe;AAC7C,WAAK,gBAAgB,cAAc,eAAe,YAAY,GAAG,iBAAiB,YAAY,CAAC;AAAA,IACjG;AAEA,SAAK,2BAA2B,KAAK,qBAAqB,KAAK,sBAAsB;AAErF,UAAM,YAAY,MAAM,KAAK,oBAAoB,KAAK,uBAAuB,QAAQ;AAErF,QAAI,CAAC,UAAU,WAAW,IAAI,GAAG;AAC/B,YAAM,KAAK,eAAe;AAAA,IAC5B;AAEA,UAAM,KAAK,OAAO,eAAe,KAAK,wBAAwB,aAAa;AAAA,EAC7E;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,MAAa,WAAW,SAAkC;AACxD,QAAI,UAAU,KAAK,yBAAyB,UAAU,KAAK,uBAAuB,QAAQ,GAAG;AAC3F;AAAA,IACF;AAEA,UAAM,KAAK,eAAe;AAC1B,UAAM,KAAK,OAAO,eAAe,KAAK,wBAAwB,KAAK,0BAA0B,OAAO;AACpG,SAAK,2BAA2B,KAAK,qBAAqB,KAAK,sBAAsB;AAAA,EACvF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAUA,MAAa,YACX,cACA,OACiB;AACjB,UAAM,KAAK,KAAK,CAAC,aAAa;AAC5B,eAAS,YAAY,IAAI;AAAA,IAC3B,CAAC;AACD,WAAO,KAAK,uBAAuB,mBAAmB,YAAY;AAAA,EACpE;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,MAAa,SAAS,UAA6G;AACjI,UAAM,SAA+D,CAAC;AACtE,eAAW,CAAC,cAAc,SAAS,KAAK,KAAK,WAAW,QAAQ,GAAG;AACjE,YAAM,oBAAoB,MAAM,UAAU,SAAS,YAAY,GAAG,QAAQ;AAC1E,UAAI,mBAAmB;AACrB,eAAO,YAAY,IAAI;AAAA,MACzB;AAAA,IACF;AAEA,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASU,iBAA8B;AACtC,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,MAAgB,aAAa,SAAuC;AAClE,UAAM,UAAU;AAAA,EAClB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,MAAgB,eAAe,SAAuC;AACpE,UAAM,UAAU;AAAA,EAClB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQU,kBACR,cACA,WACM;AACN,SAAK,WAAW,IAAI,cAAc,SAA0D;AAAA,EAC9F;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOU,qBAA2B;AACnC,SAAK;AAAA,EACP;AAAA,EAEQ,cAAc,UAAkF;AACtG,UAAM,SAAS,KAAK,oBAAoB,QAAQ;AAChD,UAAM,OAAO,KAAK,UAAU,MAAM;AAClC,UAAM,cAAc,KAAK,MAAM,IAAI;AACnC,WAAO,KAAK,oBAAoB,WAAW;AAAA,EAC7C;AAAA,EAEQ,qBACN,iBAC2D;AAC3D,WAAO;AAAA,MACL,cAAc,KAAK,cAAc,gBAAgB,YAAY;AAAA,MAC7D,UAAU,KAAK,cAAc,gBAAgB,QAAQ;AAAA,MACrD,oBAAoB,EAAE,GAAG,gBAAgB,mBAAmB;AAAA,IAC9D;AAAA,EACF;AAAA,EAEQ,+BAA0F;AAChG,WAAO;AAAA,MACL,cAAc,KAAK,sBAAsB;AAAA,MACzC,UAAU,KAAK,sBAAsB;AAAA,MACrC,oBAAoB,CAAC;AAAA,IACvB;AAAA,EACF;AAAA,EAEA,MAAc,KAAK,gBAAmG;AACpH,QAAI;AACF,YAAM,eAAe,KAAK,uBAAuB,QAAQ;AAAA,IAC3D,UAAE;AACA,YAAM,mBAAmB,MAAM,KAAK,SAAS,KAAK,uBAAuB,QAAQ;AACjF,iBAAW,gBAAgB,KAAK,eAAe;AAC7C,cAAM,oBAAoB,iBAAiB,YAAY,KAAK;AAC5D,aAAK,uBAAuB,mBAAmB,YAAY,IAAI;AAC/D,aAAK,uBAAuB,aAAa,YAAY,IAAI,oBACrD,KAAK,gBAAgB,YAAY,IACjC,KAAK,uBAAuB,SAAS,YAAY;AAAA,MACvD;AAAA,IACF;AAAA,EACF;AAAA,EAEQ,oBAAoB,MAAwE;AAClG,QAAI,OAAO,SAAS,UAAU;AAC5B,aAAO;AAAA,IACT;AAEA,WAAQ,KAAK,cAA2B,SAAS,IAAI;AAAA,EACvD;AAAA,EAEA,MAAc,oBAAoB,WAAuE;AACvG,UAAM,KAAK,aAAa,SAAS;AAEjC,UAAM,WAAW,KAAK,sBAAsB;AAE5C,eAAW,CAAC,cAAc,KAAK,KAAK,OAAO,QAAQ,SAAS,GAAG;AAC7D,UAAI,CAAC,KAAK,oBAAoB,YAAY,GAAG;AAC3C,gBAAQ,KAAK,qBAAqB,YAAY,EAAE;AAChD;AAAA,MACF;AAEA,UAAI,OAAO,UAAU,OAAO,KAAK,gBAAgB,YAAY,GAAG;AAC9D,gBAAQ;AAAA,UACN;AAAA,UACA;AAAA,YACE,cAAc,KAAK,gBAAgB,YAAY;AAAA,YAC/C;AAAA,YACA;AAAA,UACF;AAAA,QACF;AAAA,MACF;AAEA,eAAS,YAAY,IAAI;AAAA,IAC3B;AAEA,WAAO;AAAA,EACT;AAAA,EAEA,MAAc,iBAAgC;AAC5C,UAAM,KAAK,OAAO,SAAS,MAAM,KAAK,oBAAoB,KAAK,sBAAsB,CAAC;AAAA,EACxF;AAAA,EAEQ,gBACN,cACA,OACA,mBACM;AACN,SAAK,uBAAuB,SAAS,YAAY,IAAI;AACrD,SAAK,uBAAuB,mBAAmB,YAAY,IAAI,qBAAqB;AACpF,SAAK,uBAAuB,aAAa,YAAY,IAAI,oBAAoB,KAAK,gBAAgB,YAAY,IAAI;AAAA,EACpH;AAAA,EAEA,MAAc,oBAAoB,UAAsE;AACtG,UAAM,YAA2B,CAAC;AAElC,eAAW,gBAAgB,KAAK,eAAe;AAC7C,gBAAU,YAAY,IAAI,SAAS,YAAY;AAAA,IACjD;AAEA,UAAM,KAAK,eAAe,SAAS;AAEnC,WAAO,KAAK,eAAe,EAAE,2BAA2B,SAAS;AAAA,EACnE;AACF;",
  "names": []
}
