@mnaoumov/typescript-lib 0.0.0 → 1.0.1

package/dist/lib/esm/type.d.mts

@@ -0,0 +1,122 @@
+/// <reference path="./library-references.d.mts" />
+/**
+ * @file
+ *
+ * Type utilities.
+ */
+import type { GenericFunction } from './function.mjs';
+/**
+ * A type that represents the keys of an object as strings and asserts that all keys are present in a list of keys.
+ *
+ * @typeParam Type - The type of the object.
+ * @typeParam Keys - The list of keys to assert.
+ */
+export type ExactKeys<Type extends object, Keys extends readonly string[]> = ExactMembers<StringKeys<Type>, Keys>;
+/**
+ * A type that represents the members of a type.
+ *
+ * @typeParam Type - The type to assert the members of.
+ * @typeParam Keys - The list of members to assert.
+ */
+export type ExactMembers<Type extends LiteralKey, Keys extends readonly LiteralKey[]> = Exclude<Keys[number], Type> extends never ? Exclude<Type, Keys[number]> extends never ? Duplicates<Keys> extends [] ? Keys : `ERROR: Duplicate members: ${TupleToCSV<Duplicates<Keys>>}` : `ERROR: Missing members: ${TupleToCSV<UnionToTuple<Exclude<Type, Keys[number]>>>}` : `ERROR: Invalid members: ${TupleToCSV<UnionToTuple<Exclude<Keys[number], Type>>>}`;
+/**
+ * Derives an event map (`{ eventName: [callbackArgs] }`) from a type exposing an overloaded `on(name, callback)`
+ * method — e.g. Obsidian's `Workspace` / `Vault` / `MetadataCache`. Each `on` overload becomes one entry keyed by
+ * the event name, with the callback's parameters as a labeled tuple; the wide `on(name: string, …)` catch-all
+ * overload is dropped. The map auto-tracks upstream overloads (no hand-authoring). It cannot reconstruct
+ * genuinely generic overloads, but Obsidian's event overloads are all concrete string-literal ones.
+ *
+ * @typeParam T - A type exposing an `on(name, callback, …)` method (e.g. an Obsidian `Events` subclass).
+ *
+ * @example
+ * ```ts
+ * type WorkspaceEventMap = ExtractEventMap<Workspace>;
+ * // { 'file-menu': [menu: Menu, file: TAbstractFile, source: string, leaf?: WorkspaceLeaf]; … }
+ * ```
+ */
+export type ExtractEventMap<T extends EventsWithOn> = UnionToIntersection<EntryOfOverload<OverloadUnion<T['on']>>>;
+/**
+ * A type that represents a return value that may be `void`.
+ *
+ * @typeParam T - The type of the value that may be returned.
+ */
+export type MaybeReturn<T> = T | void;
+/**
+ * A type that represents the values of an object.
+ *
+ * @typeParam T - The type of the object.
+ */
+export type PropertyValues<T extends object> = T[StringKeys<T>];
+/**
+ * A type that represents the keys of an object as strings.
+ *
+ * @typeParam T - The type of the object.
+ */
+export type StringKeys<T extends object> = Extract<keyof T, string>;
+type Duplicates<T extends readonly unknown[], Seen extends readonly unknown[] = [], Added extends readonly unknown[] = [], Out extends readonly unknown[] = []> = T extends readonly [infer First, ...infer Rest] ? Includes<Seen, First> extends true ? Includes<Added, First> extends true ? Duplicates<Rest, Seen, Added, Out> : Duplicates<Rest, Seen, [...Added, First], [...Out, First]> : Duplicates<Rest, [...Seen, First], Added, Out> : Out;
+type EntryOfOverload<TOverload> = TOverload extends (name: infer Name, callback: (...$arguments: infer Arguments) => unknown, ...rest: never[]) => unknown ? Name extends string ? string extends Name ? never : Record<Name, Arguments> : never : never;
+type Equal<X, Y> = (<T>() => T extends X ? 1 : 2) extends (<T>() => T extends Y ? 1 : 2) ? true : false;
+interface EventsWithOn {
+    on: GenericFunction;
+}
+type Includes<Type extends readonly unknown[], Member> = Type extends readonly [infer First, ...infer Rest] ? Equal<First, Member> extends true ? true : Includes<Rest, Member> : false;
+type LastInUnion<Union> = UnionToIntersection<Union extends unknown ? () => Union : never> extends () => infer Last ? Last : never;
+type LiteralKey = number | string;
+type OverloadUnion<TOverload extends GenericFunction> = Exclude<OverloadUnionRecursive<(() => never) & TOverload>, TOverload extends () => never ? never : () => never>;
+type OverloadUnionRecursive<TOverload, TPartialOverload = unknown> = TOverload extends (...$arguments: infer Arguments) => infer Return ? TPartialOverload extends TOverload ? never : OverloadUnionRecursive<TPartialOverload & TOverload, TPartialOverload & ((...$arguments: Arguments) => Return) & Pick<TOverload, keyof TOverload>> | ((...$arguments: Arguments) => Return) : never;
+type ToString<T> = T extends number | string ? `${T}` : never;
+type TupleToCSV<Tuple extends readonly unknown[]> = Tuple extends readonly [infer First, ...infer Rest] ? First extends LiteralKey ? Rest extends readonly unknown[] ? Rest['length'] extends 0 ? ToString<First> : `${ToString<First>},${TupleToCSV<Rest>}` : never : never : '';
+/**
+ * Internal method shapes for {@link TypeAsserter}: a conditional type disables each method when the
+ * captured type does not support it.
+ *
+ * @typeParam Type - The captured type.
+ */
+interface TypeAssertions<Type> {
+    assertAllKeys: [Type] extends [object] ? <const Keys extends readonly string[]>(keys: ExactMembers<StringKeys<Type>, Keys>) => readonly (keyof Type)[] : never;
+    assertAllMembers: [Type] extends [LiteralKey] ? <const Keys extends readonly LiteralKey[]>(keys: ExactMembers<Type, Keys>) => readonly Type[] : never;
+}
+type UnionToIntersection<Union> = (Union extends unknown ? (key: Union) => void : never) extends (key: infer Intersection) => void ? Intersection : never;
+type UnionToTuple<Union, Last = LastInUnion<Union>> = [Union] extends [never] ? [] : [...UnionToTuple<Exclude<Union, Last>>, Last];
+/**
+ * A helper that captures a type parameter and provides methods for compile-time exhaustiveness checks.
+ *
+ * @typeParam Type - The captured type.
+ *
+ * @remarks
+ * - `assertAllKeys` is available when `Type` is an object type.
+ * - `assertAllMembers` is available when `Type` is a literal key union (`string | number`).
+ *
+ * @example
+ * ```ts
+ * type A = { a: 1, b: 2, c: 3 };
+ * new TypeAsserter<A>().assertAllKeys(['a', 'b', 'c']); // OK
+ * new TypeAsserter<A>().assertAllKeys(['c', 'a', 'b']); // OK, order is ignored
+ * new TypeAsserter<A>().assertAllKeys(['a', 'b', 'c', 'd']); // Error: Invalid members: d
+ * new TypeAsserter<A>().assertAllKeys(['a', 'b']); // Error: Missing members: c
+ *
+ * type B = 1 | 2 | 3 | 'a';
+ * new TypeAsserter<B>().assertAllMembers([1, 2, 3, 'a']); // OK
+ * new TypeAsserter<B>().assertAllMembers([1, 2, 3, 'a', 4]); // Error: Invalid members: 4
+ * new TypeAsserter<B>().assertAllMembers([1, 2, 3]); // Error: Missing members: a
+ * ```
+ */
+export declare class TypeAsserter<Type> {
+    /**
+     * Asserts that all keys of an object type are present in a list of keys.
+     *
+     * @remarks Only available when `[Type] extends [object]`.
+     */
+    readonly assertAllKeys: TypeAssertions<Type>['assertAllKeys'];
+    /**
+     * Asserts that all members of a union type are present in a list of members.
+     *
+     * @remarks Only available when `[Type] extends [LiteralKey]`.
+     */
+    readonly assertAllMembers: TypeAssertions<Type>['assertAllMembers'];
+    /**
+     * Creates a type asserter that captures {@link Type} for compile-time exhaustiveness checks.
+     */
+    constructor();
+}
+export {};

package/dist/lib/esm/type.mjs

@@ -0,0 +1,39 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+import { castTo } from "./object-utils.mjs";
+class TypeAsserter {
+  /**
+   * Asserts that all keys of an object type are present in a list of keys.
+   *
+   * @remarks Only available when `[Type] extends [object]`.
+   */
+  assertAllKeys;
+  /**
+   * Asserts that all members of a union type are present in a list of members.
+   *
+   * @remarks Only available when `[Type] extends [LiteralKey]`.
+   */
+  assertAllMembers;
+  /**
+   * Creates a type asserter that captures {@link Type} for compile-time exhaustiveness checks.
+   */
+  constructor() {
+    const assertions = castTo({
+      assertAllKeys(keys) {
+        return Object.freeze(Array.from(keys));
+      },
+      assertAllMembers(keys) {
+        return Object.freeze(Array.from(keys));
+      }
+    });
+    this.assertAllKeys = assertions.assertAllKeys;
+    this.assertAllMembers = assertions.assertAllMembers;
+  }
+}
+export {
+  TypeAsserter
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/type.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Type utilities.\n */\n\nimport type { GenericFunction } from './function.ts';\n\nimport { castTo } from './object-utils.ts';\n\n/**\n * A type that represents the keys of an object as strings and asserts that all keys are present in a list of keys.\n *\n * @typeParam Type - The type of the object.\n * @typeParam Keys - The list of keys to assert.\n */\nexport type ExactKeys<Type extends object, Keys extends readonly string[]> = ExactMembers<StringKeys<Type>, Keys>;\n\n/**\n * A type that represents the members of a type.\n *\n * @typeParam Type - The type to assert the members of.\n * @typeParam Keys - The list of members to assert.\n */\nexport type ExactMembers<\n  Type extends LiteralKey,\n  Keys extends readonly LiteralKey[]\n> = Exclude<Keys[number], Type> extends never ? Exclude<Type, Keys[number]> extends never ? Duplicates<Keys> extends [] ? Keys\n    : `ERROR: Duplicate members: ${TupleToCSV<Duplicates<Keys>>}`\n  : `ERROR: Missing members: ${TupleToCSV<UnionToTuple<Exclude<Type, Keys[number]>>>}`\n  : `ERROR: Invalid members: ${TupleToCSV<UnionToTuple<Exclude<Keys[number], Type>>>}`;\n\n/**\n * Derives an event map (`{ eventName: [callbackArgs] }`) from a type exposing an overloaded `on(name, callback)`\n * method \u2014 e.g. Obsidian's `Workspace` / `Vault` / `MetadataCache`. Each `on` overload becomes one entry keyed by\n * the event name, with the callback's parameters as a labeled tuple; the wide `on(name: string, \u2026)` catch-all\n * overload is dropped. The map auto-tracks upstream overloads (no hand-authoring). It cannot reconstruct\n * genuinely generic overloads, but Obsidian's event overloads are all concrete string-literal ones.\n *\n * @typeParam T - A type exposing an `on(name, callback, \u2026)` method (e.g. an Obsidian `Events` subclass).\n *\n * @example\n * ```ts\n * type WorkspaceEventMap = ExtractEventMap<Workspace>;\n * // { 'file-menu': [menu: Menu, file: TAbstractFile, source: string, leaf?: WorkspaceLeaf]; \u2026 }\n * ```\n */\nexport type ExtractEventMap<T extends EventsWithOn> = UnionToIntersection<EntryOfOverload<OverloadUnion<T['on']>>>;\n\n/**\n * A type that represents a return value that may be `void`.\n *\n * @typeParam T - The type of the value that may be returned.\n */\n// eslint-disable-next-line @typescript-eslint/no-invalid-void-type -- We need to use the `void` return type.\nexport type MaybeReturn<T> = T | void;\n\n/**\n * A type that represents the values of an object.\n *\n * @typeParam T - The type of the object.\n */\nexport type PropertyValues<T extends object> = T[StringKeys<T>];\n\n/**\n * A type that represents the keys of an object as strings.\n *\n * @typeParam T - The type of the object.\n */\nexport type StringKeys<T extends object> = Extract<keyof T, string>;\n\ntype Duplicates<\n  T extends readonly unknown[],\n  Seen extends readonly unknown[] = [],\n  Added extends readonly unknown[] = [],\n  Out extends readonly unknown[] = []\n> = T extends readonly [infer First, ...infer Rest] ? Includes<Seen, First> extends true ? Includes<Added, First> extends true ? Duplicates<Rest, Seen, Added, Out>\n    : Duplicates<Rest, Seen, [...Added, First], [...Out, First]>\n  : Duplicates<Rest, [...Seen, First], Added, Out>\n  : Out;\n\n// Maps one `on(name, callback, \u2026)` overload to a `{ [name]: [callbackArgs] }` entry; drops the wide `name: string` catch-all.\ntype EntryOfOverload<TOverload> = TOverload extends (name: infer Name, callback: (...$arguments: infer Arguments) => unknown, ...rest: never[]) => unknown ? Name extends string ? string extends Name ? never : Record<Name, Arguments>\n  : never\n  : never;\n\n// eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters,no-magic-numbers -- We need to use the dummy parameter to get type inference.\ntype Equal<X, Y> = (<T>() => T extends X ? 1 : 2) extends (<T>() => T extends Y ? 1 : 2) ? true : false;\n\n// The minimal shape {@link ExtractEventMap} operates on: a type exposing an overloaded `on` method.\ninterface EventsWithOn {\n  on: GenericFunction;\n}\n\ntype Includes<Type extends readonly unknown[], Member> = Type extends readonly [infer First, ...infer Rest] ? Equal<First, Member> extends true ? true : Includes<Rest, Member>\n  : false;\n\ntype LastInUnion<Union> = UnionToIntersection<Union extends unknown ? () => Union : never> extends () => infer Last ? Last : never;\n\ntype LiteralKey = number | string;\n\n// Splits an overloaded call signature into a union of its individual call signatures (a well-known overload-to-union trick).\n/* eslint-disable perfectionist/sort-intersection-types, perfectionist/sort-union-types, @stylistic/operator-linebreak -- The OverloadUnion recursion relies on this exact operand order; reordering breaks termination (TS2589), and the line-break shape is left to dprint. */\ntype OverloadUnion<TOverload extends GenericFunction> = Exclude<\n  OverloadUnionRecursive<(() => never) & TOverload>,\n  TOverload extends () => never ? never : () => never\n>;\n\ntype OverloadUnionRecursive<TOverload, TPartialOverload = unknown> = TOverload extends (...$arguments: infer Arguments) => infer Return ? TPartialOverload extends TOverload ? never\n  :\n    | OverloadUnionRecursive<TPartialOverload & TOverload, TPartialOverload & ((...$arguments: Arguments) => Return) & Pick<TOverload, keyof TOverload>>\n    | ((...$arguments: Arguments) => Return)\n  : never;\n/* eslint-enable perfectionist/sort-intersection-types, perfectionist/sort-union-types, @stylistic/operator-linebreak -- The OverloadUnion recursion relies on this exact operand order; reordering breaks termination (TS2589), and the line-break shape is left to dprint. */\n\ntype ToString<T> = T extends number | string ? `${T}` : never;\n\ntype TupleToCSV<Tuple extends readonly unknown[]> = Tuple extends readonly [infer First, ...infer Rest] ? First extends LiteralKey ? Rest extends readonly unknown[] ? Rest['length'] extends 0 ? ToString<First> : `${ToString<First>},${TupleToCSV<Rest>}`\n    : never\n  : never\n  : '';\n\n/**\n * Internal method shapes for {@link TypeAsserter}: a conditional type disables each method when the\n * captured type does not support it.\n *\n * @typeParam Type - The captured type.\n */\ninterface TypeAssertions<Type> {\n  assertAllKeys: [Type] extends [object] ? <const Keys extends readonly string[]>(\n      keys: ExactMembers<StringKeys<Type>, Keys>\n    ) => readonly (keyof Type)[]\n    : never;\n  assertAllMembers: [Type] extends [LiteralKey] ? <const Keys extends readonly LiteralKey[]>(\n      keys: ExactMembers<Type, Keys>\n    ) => readonly Type[]\n    : never;\n}\n\ntype UnionToIntersection<Union> = (Union extends unknown ? (key: Union) => void : never) extends (key: infer Intersection) => void ? Intersection : never;\n\ntype UnionToTuple<Union, Last = LastInUnion<Union>> = [Union] extends [never] ? [] : [...UnionToTuple<Exclude<Union, Last>>, Last];\n\n/**\n * A helper that captures a type parameter and provides methods for compile-time exhaustiveness checks.\n *\n * @typeParam Type - The captured type.\n *\n * @remarks\n * - `assertAllKeys` is available when `Type` is an object type.\n * - `assertAllMembers` is available when `Type` is a literal key union (`string | number`).\n *\n * @example\n * ```ts\n * type A = { a: 1, b: 2, c: 3 };\n * new TypeAsserter<A>().assertAllKeys(['a', 'b', 'c']); // OK\n * new TypeAsserter<A>().assertAllKeys(['c', 'a', 'b']); // OK, order is ignored\n * new TypeAsserter<A>().assertAllKeys(['a', 'b', 'c', 'd']); // Error: Invalid members: d\n * new TypeAsserter<A>().assertAllKeys(['a', 'b']); // Error: Missing members: c\n *\n * type B = 1 | 2 | 3 | 'a';\n * new TypeAsserter<B>().assertAllMembers([1, 2, 3, 'a']); // OK\n * new TypeAsserter<B>().assertAllMembers([1, 2, 3, 'a', 4]); // Error: Invalid members: 4\n * new TypeAsserter<B>().assertAllMembers([1, 2, 3]); // Error: Missing members: a\n * ```\n */\nexport class TypeAsserter<Type> {\n  /**\n   * Asserts that all keys of an object type are present in a list of keys.\n   *\n   * @remarks Only available when `[Type] extends [object]`.\n   */\n  public readonly assertAllKeys: TypeAssertions<Type>['assertAllKeys'];\n\n  /**\n   * Asserts that all members of a union type are present in a list of members.\n   *\n   * @remarks Only available when `[Type] extends [LiteralKey]`.\n   */\n  public readonly assertAllMembers: TypeAssertions<Type>['assertAllMembers'];\n\n  /**\n   * Creates a type asserter that captures {@link Type} for compile-time exhaustiveness checks.\n   */\n  public constructor() {\n    const assertions = castTo<TypeAssertions<Type>>({\n      assertAllKeys<const Keys extends readonly string[]>(\n        keys: ExactMembers<StringKeys<object & Type>, Keys>\n      ): readonly (keyof (object & Type))[] {\n        // eslint-disable-next-line unicorn/prefer-spread -- `Type` may be a string, and spreading one splits surrogate pairs (`@typescript-eslint/no-misused-spread`).\n        return Object.freeze(Array.from(keys) as (keyof (object & Type))[]);\n      },\n      assertAllMembers<const Keys extends readonly LiteralKey[]>(\n        keys: ExactMembers<LiteralKey & Type, Keys>\n      ): readonly (LiteralKey & Type)[] {\n        // eslint-disable-next-line unicorn/prefer-spread -- `Type` may be a string, and spreading one splits surrogate pairs (`@typescript-eslint/no-misused-spread`).\n        return Object.freeze(Array.from(keys) as (LiteralKey & Type)[]);\n      }\n    });\n    this.assertAllKeys = assertions.assertAllKeys;\n    this.assertAllMembers = assertions.assertAllMembers;\n  }\n}\n"],
  "mappings": ";;;;;AAQA,SAAS,cAAc;AA8JhB,MAAM,aAAmB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAMd;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA;AAAA;AAAA;AAAA;AAAA,EAKT,cAAc;AACnB,UAAM,aAAa,OAA6B;AAAA,MAC9C,cACE,MACoC;AAEpC,eAAO,OAAO,OAAO,MAAM,KAAK,IAAI,CAA8B;AAAA,MACpE;AAAA,MACA,iBACE,MACgC;AAEhC,eAAO,OAAO,OAAO,MAAM,KAAK,IAAI,CAA0B;AAAA,MAChE;AAAA,IACF,CAAC;AACD,SAAK,gBAAgB,WAAW;AAChC,SAAK,mBAAmB,WAAW;AAAA,EACrC;AACF;",
  "names": []
}


package/dist/lib/esm/typescript-lib-state.d.mts

@@ -0,0 +1,56 @@
+/// <reference path="./library-references.d.mts" />
+/**
+ * @file
+ *
+ * Provides access to the process-wide shared-state bag of the generic, non-Obsidian part of the library.
+ *
+ * The bag lives on `globalThis` under a `Symbol.for` key, so every copy of this module loaded in one realm shares
+ * it, whichever version it is. It holds what must exist once per realm: the debuggers, the `debug` instance and the
+ * shared abort controller. Obsidian-specific state stays in `obsidian-dev-utils-state.ts`.
+ *
+ * The slot is a cross-version wire format: its key and the {@link TypescriptLibStateSlot} shape only ever change
+ * additively.
+ */
+import { ValueWrapper } from './value-wrapper.mjs';
+/**
+ * The version of the {@link TypescriptLibStateSlot} shape this copy writes.
+ */
+export declare const TYPESCRIPT_LIB_STATE_VERSION = 1;
+/**
+ * The key of the global slot holding the {@link TypescriptLibStateSlot}.
+ */
+export declare const TYPESCRIPT_LIB_STATE_KEY: unique symbol;
+/**
+ * The shared-state slot stored on `globalThis`.
+ */
+export interface TypescriptLibStateSlot {
+    /**
+     * The shared values, each in a {@link ValueWrapper} so a holder can replace the value in place.
+     */
+    readonly values: Record<string, ValueWrapper>;
+    /**
+     * The version of the slot shape the creator wrote. Informational: the shape only changes additively.
+     */
+    readonly version: number;
+}
+/**
+ * Retrieves or creates a shared-state {@link ValueWrapper} for a given key.
+ *
+ * @typeParam T - The type of the shared state value.
+ * @param key - The key to store or retrieve the shared state under.
+ * @param defaultValue - The default value to use if the shared state does not exist yet.
+ * @returns The {@link ValueWrapper} that stores the shared state.
+ */
+export declare function getTypescriptLibState<T>(key: string, defaultValue: T): ValueWrapper<T>;
+/**
+ * Retrieves or creates the shared-state slot.
+ *
+ * @returns The {@link TypescriptLibStateSlot}.
+ */
+export declare function getTypescriptLibStateSlot(): TypescriptLibStateSlot;
+/**
+ * Clears the shared-state bag.
+ *
+ * Intended for test isolation: call it before each test so accumulated state does not leak between tests.
+ */
+export declare function resetTypescriptLibState(): void;

package/dist/lib/esm/typescript-lib-state.mjs

@@ -0,0 +1,40 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+import { ValueWrapper } from "./value-wrapper.mjs";
+const TYPESCRIPT_LIB_STATE_VERSION = 1;
+const TYPESCRIPT_LIB_STATE_KEY = /* @__PURE__ */ Symbol.for("@mnaoumov/typescript-lib/state");
+function getTypescriptLibState(key, defaultValue) {
+  return getTypescriptLibStateSlot().values[key] ??= ValueWrapper.of(defaultValue);
+}
+function getTypescriptLibStateSlot() {
+  const global = getGlobal();
+  let slot = global[TYPESCRIPT_LIB_STATE_KEY];
+  if (!slot) {
+    slot = createSlot();
+    global[TYPESCRIPT_LIB_STATE_KEY] = slot;
+  }
+  return slot;
+}
+function resetTypescriptLibState() {
+  getGlobal()[TYPESCRIPT_LIB_STATE_KEY] = createSlot();
+}
+function createSlot() {
+  return {
+    values: {},
+    version: TYPESCRIPT_LIB_STATE_VERSION
+  };
+}
+function getGlobal() {
+  return globalThis;
+}
+export {
+  TYPESCRIPT_LIB_STATE_KEY,
+  TYPESCRIPT_LIB_STATE_VERSION,
+  getTypescriptLibState,
+  getTypescriptLibStateSlot,
+  resetTypescriptLibState
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL3R5cGVzY3JpcHQtbGliLXN0YXRlLnRzIl0sCiAgInNvdXJjZXNDb250ZW50IjogWyIvKipcbiAqIEBmaWxlXG4gKlxuICogUHJvdmlkZXMgYWNjZXNzIHRvIHRoZSBwcm9jZXNzLXdpZGUgc2hhcmVkLXN0YXRlIGJhZyBvZiB0aGUgZ2VuZXJpYywgbm9uLU9ic2lkaWFuIHBhcnQgb2YgdGhlIGxpYnJhcnkuXG4gKlxuICogVGhlIGJhZyBsaXZlcyBvbiBgZ2xvYmFsVGhpc2AgdW5kZXIgYSBgU3ltYm9sLmZvcmAga2V5LCBzbyBldmVyeSBjb3B5IG9mIHRoaXMgbW9kdWxlIGxvYWRlZCBpbiBvbmUgcmVhbG0gc2hhcmVzXG4gKiBpdCwgd2hpY2hldmVyIHZlcnNpb24gaXQgaXMuIEl0IGhvbGRzIHdoYXQgbXVzdCBleGlzdCBvbmNlIHBlciByZWFsbTogdGhlIGRlYnVnZ2VycywgdGhlIGBkZWJ1Z2AgaW5zdGFuY2UgYW5kIHRoZVxuICogc2hhcmVkIGFib3J0IGNvbnRyb2xsZXIuIE9ic2lkaWFuLXNwZWNpZmljIHN0YXRlIHN0YXlzIGluIGBvYnNpZGlhbi1kZXYtdXRpbHMtc3RhdGUudHNgLlxuICpcbiAqIFRoZSBzbG90IGlzIGEgY3Jvc3MtdmVyc2lvbiB3aXJlIGZvcm1hdDogaXRzIGtleSBhbmQgdGhlIHtAbGluayBUeXBlc2NyaXB0TGliU3RhdGVTbG90fSBzaGFwZSBvbmx5IGV2ZXIgY2hhbmdlXG4gKiBhZGRpdGl2ZWx5LlxuICovXG5cbmltcG9ydCB7IFZhbHVlV3JhcHBlciB9IGZyb20gJy4vdmFsdWUtd3JhcHBlci50cyc7XG5cbi8qKlxuICogVGhlIHZlcnNpb24gb2YgdGhlIHtAbGluayBUeXBlc2NyaXB0TGliU3RhdGVTbG90fSBzaGFwZSB0aGlzIGNvcHkgd3JpdGVzLlxuICovXG5leHBvcnQgY29uc3QgVFlQRVNDUklQVF9MSUJfU1RBVEVfVkVSU0lPTiA9IDE7XG5cbi8qKlxuICogVGhlIGtleSBvZiB0aGUgZ2xvYmFsIHNsb3QgaG9sZGluZyB0aGUge0BsaW5rIFR5cGVzY3JpcHRMaWJTdGF0ZVNsb3R9LlxuICovXG5leHBvcnQgY29uc3QgVFlQRVNDUklQVF9MSUJfU1RBVEVfS0VZOiB1bmlxdWUgc3ltYm9sID0gU3ltYm9sLmZvcignQG1uYW91bW92L3R5cGVzY3JpcHQtbGliL3N0YXRlJyk7XG5cbi8qKlxuICogVGhlIHNoYXJlZC1zdGF0ZSBzbG90IHN0b3JlZCBvbiBgZ2xvYmFsVGhpc2AuXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgVHlwZXNjcmlwdExpYlN0YXRlU2xvdCB7XG4gIC8qKlxuICAgKiBUaGUgc2hhcmVkIHZhbHVlcywgZWFjaCBpbiBhIHtAbGluayBWYWx1ZVdyYXBwZXJ9IHNvIGEgaG9sZGVyIGNhbiByZXBsYWNlIHRoZSB2YWx1ZSBpbiBwbGFjZS5cbiAgICovXG4gIHJlYWRvbmx5IHZhbHVlczogUmVjb3JkPHN0cmluZywgVmFsdWVXcmFwcGVyPjtcblxuICAvKipcbiAgICogVGhlIHZlcnNpb24gb2YgdGhlIHNsb3Qgc2hhcGUgdGhlIGNyZWF0b3Igd3JvdGUuIEluZm9ybWF0aW9uYWw6IHRoZSBzaGFwZSBvbmx5IGNoYW5nZXMgYWRkaXRpdmVseS5cbiAgICovXG4gIHJlYWRvbmx5IHZlcnNpb246IG51bWJlcjtcbn1cblxudHlwZSBHbG9iYWxXaXRoVHlwZXNjcmlwdExpYlN0YXRlID0gUGFydGlhbDxSZWNvcmQ8dHlwZW9mIFRZUEVTQ1JJUFRfTElCX1NUQVRFX0tFWSwgVHlwZXNjcmlwdExpYlN0YXRlU2xvdD4+O1xuXG4vKipcbiAqIFJldHJpZXZlcyBvciBjcmVhdGVzIGEgc2hhcmVkLXN0YXRlIHtAbGluayBWYWx1ZVdyYXBwZXJ9IGZvciBhIGdpdmVuIGtleS5cbiAqXG4gKiBAdHlwZVBhcmFtIFQgLSBUaGUgdHlwZSBvZiB0aGUgc2hhcmVkIHN0YXRlIHZhbHVlLlxuICogQHBhcmFtIGtleSAtIFRoZSBrZXkgdG8gc3RvcmUgb3IgcmV0cmlldmUgdGhlIHNoYXJlZCBzdGF0ZSB1bmRlci5cbiAqIEBwYXJhbSBkZWZhdWx0VmFsdWUgLSBUaGUgZGVmYXVsdCB2YWx1ZSB0byB1c2UgaWYgdGhlIHNoYXJlZCBzdGF0ZSBkb2VzIG5vdCBleGlzdCB5ZXQuXG4gKiBAcmV0dXJucyBUaGUge0BsaW5rIFZhbHVlV3JhcHBlcn0gdGhhdCBzdG9yZXMgdGhlIHNoYXJlZCBzdGF0ZS5cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGdldFR5cGVzY3JpcHRMaWJTdGF0ZTxUPihrZXk6IHN0cmluZywgZGVmYXVsdFZhbHVlOiBUKTogVmFsdWVXcmFwcGVyPFQ+IHtcbiAgcmV0dXJuIChnZXRUeXBlc2NyaXB0TGliU3RhdGVTbG90KCkudmFsdWVzW2tleV0gPz89IFZhbHVlV3JhcHBlci5vZihkZWZhdWx0VmFsdWUpKSBhcyBWYWx1ZVdyYXBwZXI8VD47XG59XG5cbi8qKlxuICogUmV0cmlldmVzIG9yIGNyZWF0ZXMgdGhlIHNoYXJlZC1zdGF0ZSBzbG90LlxuICpcbiAqIEByZXR1cm5zIFRoZSB7QGxpbmsgVHlwZXNjcmlwdExpYlN0YXRlU2xvdH0uXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBnZXRUeXBlc2NyaXB0TGliU3RhdGVTbG90KCk6IFR5cGVzY3JpcHRMaWJTdGF0ZVNsb3Qge1xuICBjb25zdCBnbG9iYWwgPSBnZXRHbG9iYWwoKTtcbiAgbGV0IHNsb3QgPSBnbG9iYWxbVFlQRVNDUklQVF9MSUJfU1RBVEVfS0VZXTtcbiAgaWYgKCFzbG90KSB7XG4gICAgc2xvdCA9IGNyZWF0ZVNsb3QoKTtcbiAgICBnbG9iYWxbVFlQRVNDUklQVF9MSUJfU1RBVEVfS0VZXSA9IHNsb3Q7XG4gIH1cbiAgcmV0dXJuIHNsb3Q7XG59XG5cbi8qKlxuICogQ2xlYXJzIHRoZSBzaGFyZWQtc3RhdGUgYmFnLlxuICpcbiAqIEludGVuZGVkIGZvciB0ZXN0IGlzb2xhdGlvbjogY2FsbCBpdCBiZWZvcmUgZWFjaCB0ZXN0IHNvIGFjY3VtdWxhdGVkIHN0YXRlIGRvZXMgbm90IGxlYWsgYmV0d2VlbiB0ZXN0cy5cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIHJlc2V0VHlwZXNjcmlwdExpYlN0YXRlKCk6IHZvaWQge1xuICBnZXRHbG9iYWwoKVtUWVBFU0NSSVBUX0xJQl9TVEFURV9LRVldID0gY3JlYXRlU2xvdCgpO1xufVxuXG5mdW5jdGlvbiBjcmVhdGVTbG90KCk6IFR5cGVzY3JpcHRMaWJTdGF0ZVNsb3Qge1xuICByZXR1cm4ge1xuICAgIHZhbHVlczoge30sXG4gICAgdmVyc2lvbjogVFlQRVNDUklQVF9MSUJfU1RBVEVfVkVSU0lPTlxuICB9O1xufVxuXG5mdW5jdGlvbiBnZXRHbG9iYWwoKTogR2xvYmFsV2l0aFR5cGVzY3JpcHRMaWJTdGF0ZSB7XG4gIHJldHVybiBnbG9iYWxUaGlzIGFzIEdsb2JhbFdpdGhUeXBlc2NyaXB0TGliU3RhdGU7XG59XG4iXSwKICAibWFwcGluZ3MiOiAiOzs7OztBQWFBLFNBQVMsb0JBQW9CO0FBS3RCLE1BQU0sK0JBQStCO0FBS3JDLE1BQU0sMkJBQTBDLHVCQUFPLElBQUksZ0NBQWdDO0FBMkIzRixTQUFTLHNCQUF5QixLQUFhLGNBQWtDO0FBQ3RGLFNBQVEsMEJBQTBCLEVBQUUsT0FBTyxHQUFHLE1BQU0sYUFBYSxHQUFHLFlBQVk7QUFDbEY7QUFPTyxTQUFTLDRCQUFvRDtBQUNsRSxRQUFNLFNBQVMsVUFBVTtBQUN6QixNQUFJLE9BQU8sT0FBTyx3QkFBd0I7QUFDMUMsTUFBSSxDQUFDLE1BQU07QUFDVCxXQUFPLFdBQVc7QUFDbEIsV0FBTyx3QkFBd0IsSUFBSTtBQUFBLEVBQ3JDO0FBQ0EsU0FBTztBQUNUO0FBT08sU0FBUywwQkFBZ0M7QUFDOUMsWUFBVSxFQUFFLHdCQUF3QixJQUFJLFdBQVc7QUFDckQ7QUFFQSxTQUFTLGFBQXFDO0FBQzVDLFNBQU87QUFBQSxJQUNMLFFBQVEsQ0FBQztBQUFBLElBQ1QsU0FBUztBQUFBLEVBQ1g7QUFDRjtBQUVBLFNBQVMsWUFBMEM7QUFDakQsU0FBTztBQUNUOyIsCiAgIm5hbWVzIjogW10KfQo=

package/dist/lib/esm/url.d.mts

@@ -0,0 +1,74 @@
+/// <reference path="./library-references.d.mts" />
+/**
+ * @file
+ *
+ * Contains utility functions for validating, encoding and normalizing URLs.
+ */
+/**
+ * Percent-encodes the symbols that break a URL: backslashes, spaces and the control characters. Every
+ * other character — including non-ASCII ones and a literal `%` — is left as is, so the result stays
+ * readable.
+ *
+ * A literal `%` is only encoded when `shouldEncodePercent` is set. Leaving it alone is the default
+ * because it keeps the encoding idempotent for already-encoded input; the cost is that a path which
+ * genuinely contains `%` (a folder actually named `a%20b`) decodes back to something else. Turn the flag
+ * on whenever the input is a raw filesystem path that may contain `%`.
+ *
+ * @param url - The URL to encode.
+ * @param shouldEncodePercent - Whether to encode a literal `%` as `%25`. Defaults to `false`.
+ * @returns The encoded URL.
+ *
+ * @example
+ * ```ts
+ * encodeUrl(String.raw`path\to the\file.md`) // 'path%5Cto%20the%5Cfile.md'
+ * encodeUrl('a%20b') // 'a%20b'
+ * encodeUrl('a%20b', true) // 'a%2520b'
+ * ```
+ */
+export declare function encodeUrl(url: string, shouldEncodePercent?: boolean): string;
+/**
+ * Determines whether a given string is a `file://` URL.
+ *
+ * @param $string - The string to check.
+ * @returns `true` if the string uses the `file:` scheme, otherwise `false`.
+ */
+export declare function isFileUrl($string: string): boolean;
+/**
+ * Determines whether a given string is a valid URL
+ *
+ * @param $string - The string to validate as a URL.
+ * @returns `true` if the string is a valid URL, otherwise `false`.
+ */
+export declare function isUrl($string: string): boolean;
+/**
+ * Normalizes a `file://` URL to a pretty form by converting backslashes to forward slashes. The URL is
+ * expected to already be decoded. Non-`file://` URLs are returned unchanged.
+ *
+ * @param url - The URL to normalize.
+ * @returns The normalized URL.
+ */
+export declare function normalizeFileUrl(url: string): string;
+/**
+ * Converts a filesystem path into a `file:///` URL, percent-encoding it with {@link encodeUrl}.
+ *
+ * The backslashes are turned into forward slashes **after** the encoding, not before — a Windows path is
+ * encoded to `%5C` first and only then rewritten to `/`, which is what makes `C:\a b\c` produce the
+ * working `file:///C:/a%20b/c` rather than a link broken at the first space.
+ *
+ * The `file:///` prefix always ends up with exactly three slashes: any leading slashes the path already
+ * has are dropped first, because `file:////home/x` parses as the path `//home/x`, not `/home/x`. A
+ * Windows UNC path (`\\server\share`) is therefore rendered as `file:///server/share` rather than the
+ * canonical host form `file://server/share`, which this function deliberately does not produce.
+ *
+ * @param path - The filesystem path to convert.
+ * @param shouldEncodePercent - Whether to encode a literal `%` in the path as `%25`. Defaults to `false`.
+ *   See {@link encodeUrl} for the trade-off.
+ * @returns The `file:///` URL.
+ *
+ * @example
+ * ```ts
+ * pathToFileUrl(String.raw`C:\a b\c.txt`) // 'file:///C:/a%20b/c.txt'
+ * pathToFileUrl('/home/user/a b.txt') // 'file:///home/user/a%20b.txt'
+ * ```
+ */
+export declare function pathToFileUrl(path: string, shouldEncodePercent?: boolean): string;

package/dist/lib/esm/url.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
+*/
+
+import { replaceAll } from "./string.mjs";
+const SCHEME_REG_EXP = /^[A-Za-z][A-Za-z0-9+\-.]*:\S+$/;
+const FILE_SCHEME_REG_EXP = /^file:/i;
+const LEADING_SLASHES_REG_EXP = /^\/+/;
+const SPECIAL_URL_SYMBOLS_REG_EXP = /[\\\x00\x08\x0B\x0C\x0E-\x1F ]/g;
+const SPECIAL_URL_SYMBOLS_WITH_PERCENT_REG_EXP = /[%\\\x00\x08\x0B\x0C\x0E-\x1F ]/g;
+function encodeUrl(url, shouldEncodePercent) {
+  return replaceAll({
+    $string: url,
+    replacer: ({ substring: specialUrlSymbol }) => encodeURIComponent(specialUrlSymbol),
+    searchValue: shouldEncodePercent ? SPECIAL_URL_SYMBOLS_WITH_PERCENT_REG_EXP : SPECIAL_URL_SYMBOLS_REG_EXP
+  });
+}
+function isFileUrl($string) {
+  return FILE_SCHEME_REG_EXP.test($string);
+}
+function isUrl($string) {
+  if (/\s/.test($string)) {
+    return false;
+  }
+  if ($string.includes("://")) {
+    try {
+      new URL($string);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  return SCHEME_REG_EXP.test($string);
+}
+function normalizeFileUrl(url) {
+  return isFileUrl(url) ? url.replaceAll("\\", "/") : url;
+}
+function pathToFileUrl(path, shouldEncodePercent) {
+  const encodedPath = encodeUrl(path, shouldEncodePercent).replaceAll("%5C", "/");
+  return `file:///${encodedPath.replace(LEADING_SLASHES_REG_EXP, "")}`;
+}
+export {
+  encodeUrl,
+  isFileUrl,
+  isUrl,
+  normalizeFileUrl,
+  pathToFileUrl
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/url.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Contains utility functions for validating, encoding and normalizing URLs.\n */\n\nimport { replaceAll } from './string.ts';\n\nconst SCHEME_REG_EXP = /^[A-Za-z][A-Za-z0-9+\\-.]*:\\S+$/;\n\nconst FILE_SCHEME_REG_EXP = /^file:/i;\n\nconst LEADING_SLASHES_REG_EXP = /^\\/+/;\n\n/**\n * Regular expression for the symbols that have to be percent-encoded in a URL.\n */\n// eslint-disable-next-line no-control-regex, unicorn/prefer-unicode-code-point-escapes -- The regular expression is written to capture control characters, which are conventionally spelled as `\\x` escapes; `\\u{0}`-style escapes would obscure the `\\x0E-\\x1F` range without expressing anything the two-digit form cannot.\nconst SPECIAL_URL_SYMBOLS_REG_EXP = /[\\\\\\x00\\x08\\x0B\\x0C\\x0E-\\x1F ]/g;\n\n/**\n * Same as {@link SPECIAL_URL_SYMBOLS_REG_EXP}, but additionally matches a literal `%`.\n */\n// eslint-disable-next-line no-control-regex, unicorn/prefer-unicode-code-point-escapes -- The regular expression is written to capture control characters, which are conventionally spelled as `\\x` escapes; `\\u{0}`-style escapes would obscure the `\\x0E-\\x1F` range without expressing anything the two-digit form cannot.\nconst SPECIAL_URL_SYMBOLS_WITH_PERCENT_REG_EXP = /[%\\\\\\x00\\x08\\x0B\\x0C\\x0E-\\x1F ]/g;\n\n/**\n * Percent-encodes the symbols that break a URL: backslashes, spaces and the control characters. Every\n * other character \u2014 including non-ASCII ones and a literal `%` \u2014 is left as is, so the result stays\n * readable.\n *\n * A literal `%` is only encoded when `shouldEncodePercent` is set. Leaving it alone is the default\n * because it keeps the encoding idempotent for already-encoded input; the cost is that a path which\n * genuinely contains `%` (a folder actually named `a%20b`) decodes back to something else. Turn the flag\n * on whenever the input is a raw filesystem path that may contain `%`.\n *\n * @param url - The URL to encode.\n * @param shouldEncodePercent - Whether to encode a literal `%` as `%25`. Defaults to `false`.\n * @returns The encoded URL.\n *\n * @example\n * ```ts\n * encodeUrl(String.raw`path\\to the\\file.md`) // 'path%5Cto%20the%5Cfile.md'\n * encodeUrl('a%20b') // 'a%20b'\n * encodeUrl('a%20b', true) // 'a%2520b'\n * ```\n */\nexport function encodeUrl(url: string, shouldEncodePercent?: boolean): string {\n  return replaceAll({\n    $string: url,\n    replacer: ({ substring: specialUrlSymbol }) => encodeURIComponent(specialUrlSymbol),\n    searchValue: shouldEncodePercent ? SPECIAL_URL_SYMBOLS_WITH_PERCENT_REG_EXP : SPECIAL_URL_SYMBOLS_REG_EXP\n  });\n}\n\n/**\n * Determines whether a given string is a `file://` URL.\n *\n * @param $string - The string to check.\n * @returns `true` if the string uses the `file:` scheme, otherwise `false`.\n */\nexport function isFileUrl($string: string): boolean {\n  return FILE_SCHEME_REG_EXP.test($string);\n}\n\n/**\n * Determines whether a given string is a valid URL\n *\n * @param $string - The string to validate as a URL.\n * @returns `true` if the string is a valid URL, otherwise `false`.\n */\nexport function isUrl($string: string): boolean {\n  if (/\\s/.test($string)) {\n    return false;\n  }\n  if ($string.includes('://')) {\n    try {\n      new URL($string);\n      return true;\n    } catch {\n      return false;\n    }\n  }\n\n  return SCHEME_REG_EXP.test($string);\n}\n\n/**\n * Normalizes a `file://` URL to a pretty form by converting backslashes to forward slashes. The URL is\n * expected to already be decoded. Non-`file://` URLs are returned unchanged.\n *\n * @param url - The URL to normalize.\n * @returns The normalized URL.\n */\nexport function normalizeFileUrl(url: string): string {\n  return isFileUrl(url) ? url.replaceAll('\\\\', '/') : url;\n}\n\n/**\n * Converts a filesystem path into a `file:///` URL, percent-encoding it with {@link encodeUrl}.\n *\n * The backslashes are turned into forward slashes **after** the encoding, not before \u2014 a Windows path is\n * encoded to `%5C` first and only then rewritten to `/`, which is what makes `C:\\a b\\c` produce the\n * working `file:///C:/a%20b/c` rather than a link broken at the first space.\n *\n * The `file:///` prefix always ends up with exactly three slashes: any leading slashes the path already\n * has are dropped first, because `file:////home/x` parses as the path `//home/x`, not `/home/x`. A\n * Windows UNC path (`\\\\server\\share`) is therefore rendered as `file:///server/share` rather than the\n * canonical host form `file://server/share`, which this function deliberately does not produce.\n *\n * @param path - The filesystem path to convert.\n * @param shouldEncodePercent - Whether to encode a literal `%` in the path as `%25`. Defaults to `false`.\n *   See {@link encodeUrl} for the trade-off.\n * @returns The `file:///` URL.\n *\n * @example\n * ```ts\n * pathToFileUrl(String.raw`C:\\a b\\c.txt`) // 'file:///C:/a%20b/c.txt'\n * pathToFileUrl('/home/user/a b.txt') // 'file:///home/user/a%20b.txt'\n * ```\n */\nexport function pathToFileUrl(path: string, shouldEncodePercent?: boolean): string {\n  const encodedPath = encodeUrl(path, shouldEncodePercent).replaceAll('%5C', '/');\n  return `file:///${encodedPath.replace(LEADING_SLASHES_REG_EXP, '')}`;\n}\n"],
  "mappings": ";;;;;AAMA,SAAS,kBAAkB;AAE3B,MAAM,iBAAiB;AAEvB,MAAM,sBAAsB;AAE5B,MAAM,0BAA0B;AAMhC,MAAM,8BAA8B;AAMpC,MAAM,2CAA2C;AAuB1C,SAAS,UAAU,KAAa,qBAAuC;AAC5E,SAAO,WAAW;AAAA,IAChB,SAAS;AAAA,IACT,UAAU,CAAC,EAAE,WAAW,iBAAiB,MAAM,mBAAmB,gBAAgB;AAAA,IAClF,aAAa,sBAAsB,2CAA2C;AAAA,EAChF,CAAC;AACH;AAQO,SAAS,UAAU,SAA0B;AAClD,SAAO,oBAAoB,KAAK,OAAO;AACzC;AAQO,SAAS,MAAM,SAA0B;AAC9C,MAAI,KAAK,KAAK,OAAO,GAAG;AACtB,WAAO;AAAA,EACT;AACA,MAAI,QAAQ,SAAS,KAAK,GAAG;AAC3B,QAAI;AACF,UAAI,IAAI,OAAO;AACf,aAAO;AAAA,IACT,QAAQ;AACN,aAAO;AAAA,IACT;AAAA,EACF;AAEA,SAAO,eAAe,KAAK,OAAO;AACpC;AASO,SAAS,iBAAiB,KAAqB;AACpD,SAAO,UAAU,GAAG,IAAI,IAAI,WAAW,MAAM,GAAG,IAAI;AACtD;AAyBO,SAAS,cAAc,MAAc,qBAAuC;AACjF,QAAM,cAAc,UAAU,MAAM,mBAAmB,EAAE,WAAW,OAAO,GAAG;AAC9E,SAAO,WAAW,YAAY,QAAQ,yBAAyB,EAAE,CAAC;AACpE;",
  "names": []
}


package/dist/lib/esm/value-provider.d.mts

@@ -0,0 +1,29 @@
+/// <reference path="./library-references.d.mts" />
+/// <reference lib="dom" />
+/**
+ * @file
+ *
+ * Contains utility types and functions for handling value providers, which can be either direct values or functions that return values.
+ */
+import type { Promisable } from 'type-fest';
+/**
+ * Value provider that can either be a direct value of type {@link Value} or a function that returns a value of type {@link Value}.
+ *
+ * @typeParam Value - The type of the value provided.
+ * @typeParam Arguments - The types of arguments passed to the function if the provider is a function.
+ */
+export type ValueProvider<Value, Arguments extends object = object> = (($arguments: Arguments & CommonArguments) => Promisable<Value>) | Value;
+interface CommonArguments {
+    abortSignal: AbortSignal;
+}
+/**
+ * Resolves a value from a value provider, which can be either a direct value or a function that returns a value.
+ *
+ * @typeParam Arguments - The types of arguments passed to the function if the provider is a function.
+ * @typeParam Value - The type of the value provided.
+ * @param provider - The value provider to resolve.
+ * @param $arguments - The arguments to pass to the function if the provider is a function.
+ * @returns A {@link Promise} that resolves with the value provided by the value provider.
+ */
+export declare function resolveValue<Value, Arguments extends object = object>(provider: ValueProvider<Value, Arguments>, $arguments: Arguments & Partial<CommonArguments>): Promise<Value>;
+export {};

package/dist/lib/esm/value-provider.mjs

@@ -0,0 +1,18 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+import { abortSignalNever } from "./abort-controller.mjs";
+async function resolveValue(provider, $arguments) {
+  const fullArguments = { ...$arguments, abortSignal: $arguments.abortSignal ?? abortSignalNever() };
+  fullArguments.abortSignal.throwIfAborted();
+  return isFunction(provider) ? await provider(fullArguments) : provider;
+}
+function isFunction(value) {
+  return typeof value === "function";
+}
+export {
+  resolveValue
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/value-wrapper.d.mts

@@ -0,0 +1,47 @@
+/// <reference path="./library-references.d.mts" />
+/**
+ * @file
+ *
+ * Wrapper type for storing values.
+ */
+/**
+ * Wrapper type for storing values.
+ *
+ * @typeParam T - The type of the wrapped value.
+ */
+export declare class ValueWrapper<T = unknown> {
+    /**
+     * Gets the wrapped value.
+     *
+     * @returns The wrapped value.
+     * @throws An {@link Error} if the value has not been set.
+     */
+    get value(): T;
+    /**
+     * Sets the wrapped value.
+     *
+     * @param value - The value to wrap.
+     */
+    set value(value: T);
+    private _value;
+    private hasValue;
+    /**
+     * Creates a new value wrapper. Use {@link ValueWrapper.of} or {@link ValueWrapper.unset} instead.
+     */
+    private constructor();
+    /**
+     * Make wrapper from the value.
+     *
+     * @typeParam T - Type of the value to wrap.
+     * @param value - The value to wrap.
+     * @returns The wrapper.
+     */
+    static of<T>(value: T): ValueWrapper<T>;
+    /**
+     * Make the wrapper with unset value.
+     *
+     * @typeParam T - Type of the value to wrap.
+     * @returns The wrapper.
+     */
+    static unset<T>(): ValueWrapper<T>;
+}

package/dist/lib/esm/value-wrapper.mjs

@@ -0,0 +1,62 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+import { noop } from "./function.mjs";
+class ValueWrapper {
+  /**
+   * Gets the wrapped value.
+   *
+   * @returns The wrapped value.
+   * @throws An {@link Error} if the value has not been set.
+   */
+  get value() {
+    if (!this.hasValue) {
+      throw new Error("Value is not set");
+    }
+    return this._value;
+  }
+  /**
+   * Sets the wrapped value.
+   *
+   * @param value - The value to wrap.
+   */
+  set value(value) {
+    this._value = value;
+    this.hasValue = true;
+  }
+  _value = null;
+  hasValue = false;
+  /**
+   * Creates a new value wrapper. Use {@link ValueWrapper.of} or {@link ValueWrapper.unset} instead.
+   */
+  constructor() {
+    noop();
+  }
+  /**
+   * Make wrapper from the value.
+   *
+   * @typeParam T - Type of the value to wrap.
+   * @param value - The value to wrap.
+   * @returns The wrapper.
+   */
+  static of(value) {
+    const wrapper = new ValueWrapper();
+    wrapper.value = value;
+    return wrapper;
+  }
+  /**
+   * Make the wrapper with unset value.
+   *
+   * @typeParam T - Type of the value to wrap.
+   * @returns The wrapper.
+   */
+  static unset() {
+    return new ValueWrapper();
+  }
+}
+export {
+  ValueWrapper
+};
+//# sourceMappingURL=data:application/json;base64,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