Releasing 0.25.77 (#968)

Squash commits

src/common/KeyValueDB.ts

@@ -2,7 +2,7 @@ import { deleteDB, type IDBPDatabase, openDB } from "idb";
 import type { KeyValueDatabase } from "@lib/interfaces/KeyValueDatabase.ts";
 import { serialized } from "octagonal-wheels/concurrency/lock";
 import { Logger } from "octagonal-wheels/common/logger";
-const databaseCache: { [key: string]: IDBPDatabase<any> } = {};
+const databaseCache: { [key: string]: IDBPDatabase<unknown> } = {};
 export { OpenKeyValueDatabase } from "./KeyValueDBv2.ts";
 
 export const _OpenKeyValueDatabase = async (dbKey: string): Promise<KeyValueDatabase> => {
@@ -11,7 +11,7 @@ export const _OpenKeyValueDatabase = async (dbKey: string): Promise<KeyValueData
         delete databaseCache[dbKey];
     }
     const storeKey = dbKey;
-    let db: IDBPDatabase<any> | null = null;
+    let db: IDBPDatabase<unknown> | null = null;
     const _openDB = () => {
         return serialized("keyvaluedb-" + dbKey, async () => {
             const dbInstance = await openDB(dbKey, 1, {

src/common/KeyValueDBv2.ts

@@ -28,7 +28,7 @@ export async function OpenKeyValueDatabase(dbKey: string): Promise<KeyValueDatab
 }
 
 export class IDBKeyValueDatabase implements KeyValueDatabase {
-    protected _dbPromise: Promise<IDBPDatabase<any>> | null = null;
+    protected _dbPromise: Promise<IDBPDatabase<unknown>> | null = null;
     protected dbKey: string;
     protected storeKey: string;
     protected _isDestroyed: boolean = false;
@@ -104,7 +104,7 @@ export class IDBKeyValueDatabase implements KeyValueDatabase {
             this.destroyedPromise = Promise.resolve();
         }
     }
-    get DB(): Promise<IDBPDatabase<any>> {
+    get DB(): Promise<IDBPDatabase<unknown>> {
         if (this._isDestroyed) {
             return Promise.reject(new Error("Database is destroyed"));
         }
@@ -117,7 +117,7 @@ export class IDBKeyValueDatabase implements KeyValueDatabase {
     }
     async get<U>(key: IDBValidKey): Promise<U> {
         const db = await this.DB;
-        return await db.get(this.storeKey, key);
+        return (await db.get(this.storeKey, key)) as U;
     }
     async set<U>(key: IDBValidKey, value: U): Promise<IDBValidKey> {
         const db = await this.DB;

src/common/PeriodicProcessor.ts

@@ -4,10 +4,10 @@ import { eventHub, EVENT_PLUGIN_UNLOADED } from "./events";
 import type { NecessaryServices } from "@lib/interfaces/ServiceModule";
 type PeriodicProcessorHost = NecessaryServices<"API" | "control", never>;
 export class PeriodicProcessor {
-    _process: () => Promise<any>;
+    _process: () => Promise<unknown>;
     _timer?: number = undefined;
     _core: PeriodicProcessorHost;
-    constructor(core: PeriodicProcessorHost, process: () => Promise<any>) {
+    constructor(core: PeriodicProcessorHost, process: () => Promise<unknown>) {
         // this._plugin = plugin;
         this._core = core;
         this._process = process;

src/common/reportTool.ts

@@ -9,16 +9,16 @@ import { isCloudantURI } from "@lib/pouchdb/utils_couchdb";
 import { compatGlobal } from "@lib/common/coreEnvFunctions";
 import { manifestVersion, packageVersion } from "@lib/common/coreEnvVars";
 import type { LiveSyncBaseCore } from "@/LiveSyncBaseCore";
-function redactObject(obj: Record<string, any>, dotted: string, redactedValue = "REDACTED") {
+function redactObject(obj: Record<string, unknown>, dotted: string, redactedValue = "REDACTED") {
     const keys = dotted.split(".");
     let current = obj;
     for (let i = 0; i < keys.length - 1; i++) {
         const key = keys[i];
         if (!(key in current)) {
-            current[key] = {} as Record<string, any>;
+            current[key] = {};
         }
         // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-        current = current[key];
+        current = current[key] as Record<string, unknown>;
     }
     const lastKey = keys[keys.length - 1];
     if (lastKey in current) {
@@ -27,7 +27,7 @@ function redactObject(obj: Record<string, any>, dotted: string, redactedValue =
     return obj;
 }
 export async function generateReport(settings: ObsidianLiveSyncSettings, core: LiveSyncBaseCore) {
-    let responseConfig: Record<string, any> = {};
+    let responseConfig: Record<string, unknown> = {};
     const REDACTED = "𝑅𝐸𝐷𝐴𝐶𝑇𝐸𝐷";
     if (settings.remoteType == REMOTE_COUCHDB) {
         try {
@@ -42,7 +42,7 @@ export async function generateReport(settings: ObsidianLiveSyncSettings, core: L
                 undefined,
                 customHeaders
             );
-            responseConfig = r.json as Record<string, any>;
+            responseConfig = r.json as Record<string, unknown>;
             redactObject(responseConfig, "couch_httpd_auth.secret");
             redactObject(responseConfig, "couch_httpd_auth.authentication_db");
             redactObject(responseConfig, "couch_httpd_auth.authentication_redirect");

src/common/utils.ts

@@ -72,7 +72,7 @@ import {
 } from "@lib/common/typeUtils.ts";
 export { isInternalFile, getPathFromUXFileInfo, getStoragePathFromUXFileInfo, getDatabasePathFromUXFileInfo };
 
-const memos: { [key: string]: any } = {};
+const memos: { [key: string]: unknown } = {};
 export function memoObject<T>(key: string, obj: T): T {
     memos[key] = obj;
     return memos[key] as T;
@@ -87,7 +87,7 @@ export async function memoIfNotExist<T>(key: string, func: () => T | Promise<T>)
 }
 export function retrieveMemoObject<T>(key: string): T | false {
     if (key in memos) {
-        return memos[key];
+        return memos[key] as T;
     } else {
         return false;
     }
@@ -128,7 +128,7 @@ export const _requestToCouchDBFetch = async (
     username: string,
     password: string,
     path?: string,
-    body?: any,
+    body?: unknown,
     method?: string
 ) => {
     const utf8str = String.fromCharCode.apply(null, [...writeString(`${username}:${password}`)]);
@@ -154,7 +154,7 @@ export const _requestToCouchDB = async (
     credentials: CouchDBCredentials,
     origin: string,
     path?: string,
-    body?: any,
+    body?: unknown,
     method?: string,
     customHeaders?: Record<string, string>
 ) => {
@@ -263,38 +263,37 @@ export function compareFileFreshness(
 const _cached = new Map<
     string,
     {
-        value: any;
-        context: Map<string, any>;
+        value: unknown;
+        context: Map<string, unknown>;
     }
 >();
 
 export type MemoOption = {
     key: string;
     forceUpdate?: boolean;
-    validator?: (context: Map<string, any>) => boolean;
+    validator?: (context: Map<string, unknown>) => boolean;
 };
 
 export function useMemo<T>(
     { key, forceUpdate, validator }: MemoOption,
-    updateFunc: (context: Map<string, any>, prev: T) => T
+    updateFunc: (context: Map<string, unknown>, prev: T) => T
 ): T {
     const cached = _cached.get(key);
-    const context = cached?.context || new Map<string, any>();
+    const context = cached?.context || new Map<string, unknown>();
     if (cached && !forceUpdate && (!validator || (validator && !validator(context)))) {
-        return cached.value;
+        return cached.value as T;
     }
-    const value = updateFunc(context, cached?.value);
+    const value = updateFunc(context, cached?.value as T);
     if (value !== cached?.value) {
         _cached.set(key, { value, context });
     }
     return value;
 }
 
-// const _static = new Map<string, any>();
 const _staticObj = new Map<
     string,
     {
-        value: any;
+        value: unknown;
     }
 >();
 
@@ -390,7 +389,7 @@ export async function autosaveCache<K, V>(db: KeyValueDatabase, mapKey: string):
     };
 }
 
-export function onlyInNTimes(n: number, proc: (progress: number) => any) {
+export function onlyInNTimes(n: number, proc: (progress: number) => unknown) {
     let counter = 0;
     return function () {
         if (counter++ % n == 0) {