@polyipseity/obsidian-plugin-library/dist/src/settings.d.ts

Library for Obsidian plugins.

import type { DeepReadonly, DeepWritable } from "ts-essentials";
import { type Fixed, type Fixer } from "./fixers.js";
import { ResourceComponent } from "./obsidian.js";
import type { PluginContext } from "./plugin.js";
export declare abstract class AbstractSettingsManager<T extends AbstractSettingsManager.Type> extends ResourceComponent<DeepReadonly<T>> {
    #private;
    protected readonly fixer: Fixer<T>;
    constructor(fixer: Fixer<T>);
    mutate(mutator: (settings: DeepWritable<T>) => unknown): Promise<void>;
    read(reader?: () => unknown): Promise<void>;
    onMutate<V>(accessor: (settings: DeepReadonly<T>) => V, callback: (cur: V, prev: V, settings: DeepReadonly<T>) => unknown): () => void;
    onload(): void;
    protected load0(): Promise<DeepReadonly<T>>;
    abstract write(): unknown;
    protected abstract onInvalidData(actual: unknown, fixed: DeepWritable<T>): unknown;
    protected abstract read0(): unknown;
}
export declare namespace AbstractSettingsManager {
    export interface Type {
        readonly [Type]?: never;
    }
    const Type: unique symbol;
    export function fix(self0: unknown): Fixed<Type>;
    export {};
}
export declare class StorageSettingsManager<T extends StorageSettingsManager.Type> extends AbstractSettingsManager<T> {
    #private;
    protected readonly context: PluginContext;
    protected readonly storage: Storage;
    constructor(context: PluginContext, fixer: Fixer<T>, storage?: Storage);
    protected get key(): PromiseLike<string | null>;
    write(): Promise<void>;
    protected onInvalidData(actual: unknown, fixed: DeepWritable<T>): Promise<void>;
    protected read0(): Promise<unknown>;
}
export declare namespace StorageSettingsManager {
    const FAILED: unique symbol, KEY = "settings", RECOVERY_PREFIX = "local-settings.";
    type Recovery = Readonly<Record<string, string>>;
    interface Type extends AbstractSettingsManager.Type {
        readonly [FAILED]?: true;
        readonly recovery: Recovery;
    }
    function fix(self0: unknown): Fixed<Type>;
    function getRecovery(recovery: Recovery, prefix: string): Map<string, string>;
    function setRecovery(recovery: DeepWritable<Recovery>, prefix: string, map: Map<string, string>): void;
    function hasFailed(value: Type): boolean;
}
export declare class SettingsManager<T extends SettingsManager.Type> extends AbstractSettingsManager<T> {
    #private;
    protected readonly context: PluginContext;
    constructor(context: PluginContext, fixer: Fixer<T>);
    write(): Promise<void>;
    protected onInvalidData(actual: unknown, fixed: DeepWritable<T>): Promise<void>;
    protected read0(): Promise<unknown>;
}
export declare namespace SettingsManager {
    type Type = AbstractSettingsManager.Type;
    const RECOVERY_PREFIX = "settings.", fix: typeof AbstractSettingsManager.fix;
}
export declare function registerSettingsCommands(context: PluginContext): void;
//# sourceMappingURL=settings.d.ts.map