npm - @sv443-network/userutils - Versions diffs - 8.3.3 → 9.0.0 - Mend

@sv443-network/userutils 8.3.3 → 9.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (21) hide show

package/CHANGELOG.md +54 -2
package/README-summary.md +191 -0
package/README.md +77 -2548
package/dist/index.cjs +346 -101
package/dist/index.global.js +351 -106
package/dist/index.js +343 -102
package/dist/lib/DataStore.d.ts +77 -81
package/dist/lib/DataStoreSerializer.d.ts +13 -13
package/dist/lib/Debouncer.d.ts +77 -0
package/dist/lib/Dialog.d.ts +5 -5
package/dist/lib/SelectorObserver.d.ts +30 -33
package/dist/lib/array.d.ts +2 -2
package/dist/lib/colors.d.ts +10 -10
package/dist/lib/crypto.d.ts +11 -11
package/dist/lib/dom.d.ts +43 -42
package/dist/lib/index.d.ts +1 -0
package/dist/lib/math.d.ts +13 -8
package/dist/lib/misc.d.ts +29 -17
package/dist/lib/translation.d.ts +140 -14
package/dist/lib/types.d.ts +12 -10
package/package.json +44 -39

package/dist/lib/dom.d.ts CHANGED Viewed

@@ -1,73 +1,74 @@
 /**
- * Returns `unsafeWindow` if the `@grant unsafeWindow` is given, otherwise falls back to the regular `window`
+ * Returns `unsafeWindow` if the `@grant unsafeWindow` is given, otherwise falls back to the regular `window`
  */
 export declare function getUnsafeWindow(): Window;
 /**
- * Adds a parent container around the provided element
- * @returns Returns the new parent element
+ * Adds a parent container around the provided element
+ * @returns Returns the new parent element
  */
 export declare function addParent<TElem extends Element, TParentElem extends Element>(element: TElem, newParent: TParentElem): TParentElem;
 /**
- * Adds global CSS style in the form of a `<style>` element in the document's `<head>`
- * This needs to be run after the `DOMContentLoaded` event has fired on the document object (or instantly if `@run-at document-end` is used).
- * @param style CSS string
- * @returns Returns the created style element
+ * Adds global CSS style in the form of a `<style>` element in the document's `<head>`
+ * This needs to be run after the `DOMContentLoaded` event has fired on the document object (or instantly if `@run-at document-end` is used).
+ * @param style CSS string
+ * @returns Returns the created style element
  */
 export declare function addGlobalStyle(style: string): HTMLStyleElement;
 /**
- * Preloads an array of image URLs so they can be loaded instantly from the browser cache later on
- * @param rejects If set to `true`, the returned PromiseSettledResults will contain rejections for any of the images that failed to load
- * @returns Returns an array of `PromiseSettledResult` - each resolved result will contain the loaded image element, while each rejected result will contain an `ErrorEvent`
+ * Preloads an array of image URLs so they can be loaded instantly from the browser cache later on
+ * @param rejects If set to `true`, the returned PromiseSettledResults will contain rejections for any of the images that failed to load
+ * @returns Returns an array of `PromiseSettledResult` - each resolved result will contain the loaded image element, while each rejected result will contain an `ErrorEvent`
  */
 export declare function preloadImages(srcUrls: string[], rejects?: boolean): Promise<PromiseSettledResult<HTMLImageElement>[]>;
 /**
- * Tries to use `GM.openInTab` to open the given URL in a new tab, otherwise if the grant is not given, creates an invisible anchor element and clicks it.
- * For the fallback to work, this function needs to be run in response to a user interaction event, else the browser might reject it.
- * @param href The URL to open in a new tab
- * @param background If set to `true`, the tab will be opened in the background - set to `undefined` (default) to use the browser's default behavior
+ * Tries to use `GM.openInTab` to open the given URL in a new tab, otherwise if the grant is not given, creates an invisible anchor element and clicks it.
+ * For the fallback to work, this function needs to be run in response to a user interaction event, else the browser might reject it.
+ * @param href The URL to open in a new tab
+ * @param background If set to `true`, the tab will be opened in the background - set to `undefined` (default) to use the browser's default behavior
+ * @param additionalProps Additional properties to set on the anchor element (only applies when `GM.openInTab` is not available)
  */
-export declare function openInNewTab(href: string, background?: boolean): void;
+export declare function openInNewTab(href: string, background?: boolean, additionalProps?: Partial<HTMLAnchorElement>): void;
 /**
- * Intercepts the specified event on the passed object and prevents it from being called if the called {@linkcode predicate} function returns a truthy value.
- * If no predicate is specified, all events will be discarded.
- * This function should be called as soon as possible (I recommend using `@run-at document-start`), as it will only intercept events that are added after this function is called.
- * Calling this function will set `Error.stackTraceLimit = 100` (if not already higher) to ensure the stack trace is preserved.
+ * Intercepts the specified event on the passed object and prevents it from being called if the called {@linkcode predicate} function returns a truthy value.
+ * If no predicate is specified, all events will be discarded.
+ * This function should be called as soon as possible (I recommend using `@run-at document-start`), as it will only intercept events that are added after this function is called.
+ * Calling this function will set `Error.stackTraceLimit = 100` (if not already higher) to ensure the stack trace is preserved.
  */
 export declare function interceptEvent<TEvtObj extends EventTarget, TPredicateEvt extends Event>(eventObject: TEvtObj, eventName: Parameters<TEvtObj["addEventListener"]>[0], predicate?: (event: TPredicateEvt) => boolean): void;
 /**
- * Intercepts the specified event on the window object and prevents it from being called if the called {@linkcode predicate} function returns a truthy value.
- * If no predicate is specified, all events will be discarded.
- * This function should be called as soon as possible (I recommend using `@run-at document-start`), as it will only intercept events that are added after this function is called.
- * Calling this function will set `Error.stackTraceLimit = 100` (if not already higher) to ensure the stack trace is preserved.
+ * Intercepts the specified event on the window object and prevents it from being called if the called {@linkcode predicate} function returns a truthy value.
+ * If no predicate is specified, all events will be discarded.
+ * This function should be called as soon as possible (I recommend using `@run-at document-start`), as it will only intercept events that are added after this function is called.
+ * Calling this function will set `Error.stackTraceLimit = 100` (if not already higher) to ensure the stack trace is preserved.
  */
 export declare function interceptWindowEvent<TEvtKey extends keyof WindowEventMap>(eventName: TEvtKey, predicate?: (event: WindowEventMap[TEvtKey]) => boolean): void;
 /** Checks if an element is scrollable in the horizontal and vertical directions */
 export declare function isScrollable(element: Element): Record<"vertical" | "horizontal", boolean>;
 /**
- * Executes the callback when the passed element's property changes.
- * Contrary to an element's attributes, properties can usually not be observed with a MutationObserver.
- * This function shims the getter and setter of the property to invoke the callback.
- *
- * [Source](https://stackoverflow.com/a/61975440)
- * @param property The name of the property to observe
- * @param callback Callback to execute when the value is changed
+ * Executes the callback when the passed element's property changes.
+ * Contrary to an element's attributes, properties can usually not be observed with a MutationObserver.
+ * This function shims the getter and setter of the property to invoke the callback.
+ *
+ * [Source](https://stackoverflow.com/a/61975440)
+ * @param property The name of the property to observe
+ * @param callback Callback to execute when the value is changed
  */
 export declare function observeElementProp<TElem extends Element = HTMLElement, TPropKey extends keyof TElem = keyof TElem>(element: TElem, property: TPropKey, callback: (oldVal: TElem[TPropKey], newVal: TElem[TPropKey]) => void): void;
 /**
- * Returns a "frame" of the closest siblings of the {@linkcode refElement}, based on the passed amount of siblings and {@linkcode refElementAlignment}
- * @param refElement The reference element to return the relative closest siblings from
- * @param siblingAmount The amount of siblings to return
- * @param refElementAlignment Can be set to `center-top` (default), `center-bottom`, `top`, or `bottom`, which will determine where the relative location of the provided {@linkcode refElement} is in the returned array
- * @param includeRef If set to `true` (default), the provided {@linkcode refElement} will be included in the returned array at the corresponding position
- * @template TSibling The type of the sibling elements that are returned
- * @returns An array of sibling elements
+ * Returns a "frame" of the closest siblings of the {@linkcode refElement}, based on the passed amount of siblings and {@linkcode refElementAlignment}
+ * @param refElement The reference element to return the relative closest siblings from
+ * @param siblingAmount The amount of siblings to return
+ * @param refElementAlignment Can be set to `center-top` (default), `center-bottom`, `top`, or `bottom`, which will determine where the relative location of the provided {@linkcode refElement} is in the returned array
+ * @param includeRef If set to `true` (default), the provided {@linkcode refElement} will be included in the returned array at the corresponding position
+ * @template TSibling The type of the sibling elements that are returned
+ * @returns An array of sibling elements
  */
 export declare function getSiblingsFrame<TSibling extends Element = HTMLElement>(refElement: Element, siblingAmount: number, refElementAlignment?: "center-top" | "center-bottom" | "top" | "bottom", includeRef?: boolean): TSibling[];
 /**
- * Sets the innerHTML property of the provided element without any sanitation or validation.
- * Uses a [Trusted Types policy](https://developer.mozilla.org/en-US/docs/Web/API/Trusted_Types_API) on Chromium-based browsers to trick the browser into thinking the HTML is safe.
- * Use this if the page makes use of the CSP directive `require-trusted-types-for 'script'` and throws a "This document requires 'TrustedHTML' assignment" error on Chromium-based browsers.
- *
- * ⚠️ This function does not perform any sanitization and should thus be used with utmost caution, as it can easily lead to XSS vulnerabilities!
+ * Sets the innerHTML property of the provided element without any sanitation or validation.
+ * Uses a [Trusted Types policy](https://developer.mozilla.org/en-US/docs/Web/API/Trusted_Types_API) on Chromium-based browsers to trick the browser into thinking the HTML is safe.
+ * Use this if the page makes use of the CSP directive `require-trusted-types-for 'script'` and throws a "This document requires 'TrustedHTML' assignment" error on Chromium-based browsers.
+ *
+ * - ⚠️ This function does not perform any sanitization and should thus be used with utmost caution, as it can easily lead to XSS vulnerabilities!
  */
 export declare function setInnerHtmlUnsafe<TElement extends Element = HTMLElement>(element: TElement, html: string): TElement;

package/dist/lib/index.d.ts CHANGED Viewed

@@ -3,6 +3,7 @@ export * from "./colors.js";
 export * from "./crypto.js";
 export * from "./DataStore.js";
 export * from "./DataStoreSerializer.js";
+export * from "./Debouncer.js";
 export * from "./Dialog.js";
 export * from "./dom.js";
 export * from "./math.js";

package/dist/lib/math.d.ts CHANGED Viewed

@@ -1,22 +1,27 @@
+import type { Stringifiable } from "./types.js";
 /** Ensures the passed {@linkcode value} always stays between {@linkcode min} and {@linkcode max} */
 export declare function clamp(value: number, min: number, max: number): number;
+/** Ensures the passed {@linkcode value} always stays between 0 and {@linkcode max} */
+export declare function clamp(value: number, max: number): number;
 /**
- * Transforms the value parameter from the numerical range `range1min` to `range1max` to the numerical range `range2min` to `range2max`
- * For example, you can map the value 2 in the range of 0-5 to the range of 0-10 and you'd get a 4 as a result.
+ * Transforms the value parameter from the numerical range `range1min` to `range1max` to the numerical range `range2min` to `range2max`
+ * For example, you can map the value 2 in the range of 0-5 to the range of 0-10 and you'd get a 4 as a result.
  */
 export declare function mapRange(value: number, range1min: number, range1max: number, range2min: number, range2max: number): number;
 /**
- * Transforms the value parameter from the numerical range `0` to `range1max` to the numerical range `0` to `range2max`
- * For example, you can map the value 2 in the range of 0-5 to the range of 0-10 and you'd get a 4 as a result.
+ * Transforms the value parameter from the numerical range `0` to `range1max` to the numerical range `0` to `range2max`
+ * For example, you can map the value 2 in the range of 0-5 to the range of 0-10 and you'd get a 4 as a result.
  */
 export declare function mapRange(value: number, range1max: number, range2max: number): number;
 /**
- * Returns a random number between {@linkcode min} and {@linkcode max} (inclusive)
- * Set {@linkcode enhancedEntropy} to true to use `crypto.getRandomValues()` for better cryptographic randomness (this also makes it take longer to generate)
+ * Returns a random number between {@linkcode min} and {@linkcode max} (inclusive)
+ * Set {@linkcode enhancedEntropy} to true to use `crypto.getRandomValues()` for better cryptographic randomness (this also makes it take longer to generate)
  */
 export declare function randRange(min: number, max: number, enhancedEntropy?: boolean): number;
 /**
- * Returns a random number between 0 and {@linkcode max} (inclusive)
- * Set {@linkcode enhancedEntropy} to true to use `crypto.getRandomValues()` for better cryptographic randomness (this also makes it take longer to generate)
+ * Returns a random number between 0 and {@linkcode max} (inclusive)
+ * Set {@linkcode enhancedEntropy} to true to use `crypto.getRandomValues()` for better cryptographic randomness (this also makes it take longer to generate)
  */
 export declare function randRange(max: number, enhancedEntropy?: boolean): number;
+/** Calculates the amount of digits in the given number - the given number or string will be passed to the `Number()` constructor. Returns NaN if the number is invalid. */
+export declare function digitCount(num: number | Stringifiable): number;

package/dist/lib/misc.d.ts CHANGED Viewed

@@ -1,32 +1,44 @@
 import type { Prettify, Stringifiable } from "./types.js";
 /**
- * Automatically appends an `s` to the passed {@linkcode word}, if {@linkcode num} is not equal to 1
- * @param word A word in singular form, to auto-convert to plural
- * @param num If this is an array or NodeList, the amount of items is used
+ * Automatically appends an `s` to the passed {@linkcode word}, if {@linkcode num} is not equal to 1
+ * @param word A word in singular form, to auto-convert to plural
+ * @param num If this is an array or NodeList, the amount of items is used
  */
 export declare function autoPlural(word: Stringifiable, num: number | unknown[] | NodeList): string;
 /**
- * Inserts the passed values into a string at the respective placeholders.
- * The placeholder format is `%n`, where `n` is the 1-indexed argument number.
- * @param input The string to insert the values into
- * @param values The values to insert, in order, starting at `%1`
+ * Inserts the passed values into a string at the respective placeholders.
+ * The placeholder format is `%n`, where `n` is the 1-indexed argument number.
+ * @param input The string to insert the values into
+ * @param values The values to insert, in order, starting at `%1`
  */
 export declare function insertValues(input: string, ...values: Stringifiable[]): string;
 /** Pauses async execution for the specified time in ms */
 export declare function pauseFor(time: number): Promise<void>;
-/**
- * Calls the passed {@linkcode func} after the specified {@linkcode timeout} in ms (defaults to 300).
- * Any subsequent calls to this function will reset the timer and discard all previous calls.
- * @param func The function to call after the timeout
- * @param timeout The time in ms to wait before calling the function
- * @param edge Whether to call the function at the very first call ("rising" edge) or the very last call ("falling" edge, default)
- */
-export declare function debounce<TFunc extends (...args: TArgs[]) => void, // eslint-disable-next-line @typescript-eslint/no-explicit-any
-TArgs = any>(func: TFunc, timeout?: number, edge?: "rising" | "falling"): (...args: TArgs[]) => void;
 /** Options for the `fetchAdvanced()` function */
 export type FetchAdvancedOpts = Prettify<Partial<{
     /** Timeout in milliseconds after which the fetch call will be canceled with an AbortController signal */
     timeout: number;
 }> & RequestInit>;
 /** Calls the fetch API with special options like a timeout */
-export declare function fetchAdvanced(input: RequestInfo | URL, options?: FetchAdvancedOpts): Promise<Response>;
+export declare function fetchAdvanced(input: string | RequestInfo | URL, options?: FetchAdvancedOpts): Promise<Response>;
+/**
+ * A ValueGen value is either its type, a promise that resolves to its type, or a function that returns its type, either synchronous or asynchronous.
+ * ValueGen allows for the utmost flexibility when applied to any type, as long as {@linkcode consumeGen()} is used to get the final value.
+ * @template TValueType The type of the value that the ValueGen should yield
+ */
+export type ValueGen<TValueType> = TValueType | Promise<TValueType> | (() => TValueType | Promise<TValueType>);
+/**
+ * Turns a {@linkcode ValueGen} into its final value.
+ * @template TValueType The type of the value that the ValueGen should yield
+ */
+export declare function consumeGen<TValueType>(valGen: ValueGen<TValueType>): Promise<TValueType>;
+/**
+ * A StringGen value is either a string, anything that can be converted to a string, or a function that returns one of the previous two, either synchronous or asynchronous, or a promise that returns a string.
+ * StringGen allows for the utmost flexibility when dealing with strings, as long as {@linkcode consumeStringGen()} is used to get the final string.
+ */
+export type StringGen = ValueGen<Stringifiable>;
+/**
+ * Turns a {@linkcode StringGen} into its final string value.
+ * @template TStrUnion The union of strings that the StringGen should yield - this allows for finer type control compared to {@linkcode consumeGen()}
+ */
+export declare function consumeStringGen<TStrUnion extends string>(strGen: StringGen): Promise<TStrUnion>;

package/dist/lib/translation.d.ts CHANGED Viewed

@@ -1,19 +1,145 @@
 import type { Stringifiable } from "./types.js";
 /**
- * Returns the translated text for the specified key in the current language set by {@linkcode tr.setLanguage()}
- * Use {@linkcode tr.forLang()} to get the translation for a specific language instead of the currently set one.
- * If the key is not found in the currently set language, the key itself is returned.
- *
- * ⚠️ Remember to register a language with {@linkcode tr.addLanguage()} and set it as active with {@linkcode tr.setLanguage()} before using this function, otherwise it will always return the key itself.
- * @param key Key of the translation to return
- * @param args Optional arguments to be passed to the translated text. They will replace placeholders in the format `%n`, where `n` is the 1-indexed argument number
+ * Translation object to pass to {@linkcode tr.addTranslations()}
+ * Can be a flat object of identifier keys and the translation text as the value, or an infinitely nestable object containing the same.
+ *
+ * @example
+ * // Flat object:
+ * const tr_en: TrObject = {
+ *   hello: "Hello, %1!",
+ *   foo: "Foo",
+ * };
+ *
+ * // Nested object:
+ * const tr_de: TrObject = {
+ *   hello: "Hallo, %1!",
+ *   foo: {
+ *     bar: "Foo bar",
+ *   },
+ * };
  */
-declare function tr(key: string, ...args: Stringifiable[]): string;
-declare namespace tr {
-    var forLang: (language: string, key: string, ...args: Stringifiable[]) => string;
-    var addLanguage: (language: string, translations: Record<string, string>) => void;
-    var setLanguage: (language: string) => void;
-    var getLanguage: () => string;
-    var getTranslations: (language?: string | undefined) => Record<string, string> | undefined;
+export interface TrObject {
+    [key: string]: string | TrObject;
 }
+/** Properties for the transform function that transforms a matched translation string into something else */
+export type TransformFnProps<TTrKey extends string = string> = {
+    /** The current language - empty string if not set yet */
+    language: string;
+    /** The matches as returned by `RegExp.exec()` */
+    matches: RegExpExecArray[];
+    /** The translation key */
+    trKey: TTrKey;
+    /** Translation value before any transformations */
+    trValue: string;
+    /** Current value, possibly in-between transformations */
+    currentValue: string;
+    /** Arguments passed to the translation function */
+    trArgs: (Stringifiable | Record<string, Stringifiable>)[];
+};
+/** Function that transforms a matched translation string into another string */
+export type TransformFn<TTrKey extends string = string> = (props: TransformFnProps<TTrKey>) => Stringifiable;
+/** Transform pattern and function in tuple form */
+export type TransformTuple<TTrKey extends string = string> = [RegExp, TransformFn<TTrKey>];
+/**
+ * Pass a recursive or flat translation object to this generic type to get all keys in the object.
+ * @example ```ts
+ * type Keys = TrKeys<{ a: { b: "foo" }, c: "bar" }>;
+ * // result: type Keys = "a.b" | "c"
+ * ```
+ */
+export type TrKeys<TTrObj, P extends string = ""> = {
+    [K in keyof TTrObj]: K extends string | number | boolean | null | undefined ? TTrObj[K] extends object ? TrKeys<TTrObj[K], `${P}${K}.`> : `${P}${K}` : never;
+}[keyof TTrObj];
+/**
+ * Registers a new language and its translations - if the language already exists, it will be overwritten.
+ * The translations are a key-value pair where the key is the translation key and the value is the translated text.
+ * The translations can also be infinitely nested objects, resulting in a dot-separated key.
+ * @param language Language code or name to register - I recommend sticking to a standard like [ISO 639](https://en.wikipedia.org/wiki/List_of_ISO_639-1_codes) or [BCP 47](https://en.wikipedia.org/wiki/IETF_language_tag)
+ * @param translations Translations for the specified language
+ * @example ```ts
+ * tr.addTranslations("en", {
+ *   hello: "Hello, %1!",
+ *   foo: {
+ *     bar: "Foo bar",
+ *   },
+ * });
+ * ```
+ */
+declare function addTranslations(language: string, translations: TrObject): void;
+/**
+ * Returns the translation object for the specified language or currently active one.
+ * If the language is not registered with {@linkcode tr.addTranslations()}, this function will return `undefined`.
+ * @param language Language code or name to get translations for - defaults to the currently active language (set by {@linkcode tr.setLanguage()})
+ * @returns Translations for the specified language
+ */
+declare function getTranslations(language?: string): TrObject | undefined;
+/**
+ * The fallback language to use when a translation key is not found in the currently active language.
+ * Leave undefined to disable fallbacks and just return the translation key if translations are not found.
+ */
+declare function setFallbackLanguage(fallbackLanguage?: string): void;
+/** Returns the fallback language set by {@linkcode tr.setFallbackLanguage()} */
+declare function getFallbackLanguage(): string | undefined;
+/**
+ * Adds a transform function that gets called after resolving a translation for any language.
+ * Use it to enable dynamic values in translations, for example to insert custom global values from the application or to denote a section that could be encapsulated by rich text.
+ * Each function will receive the RegExpMatchArray [see MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/match) and the current language as arguments.
+ * After all %n-formatted values have been injected, the transform functions will be called sequentially in the order they were added.
+ * @example
+ * ```ts
+ * tr.addTranslations("en", {
+ *    "greeting": {
+ *      "with_username": "Hello, ${USERNAME}",
+ *      "headline_html": "Hello, ${USERNAME}<br><c=red>You have ${UNREAD_NOTIFS} unread notifications.</c>"
+ *    }
+ * });
+ *
+ * // replace ${PATTERN}
+ * tr.addTransform(/<\$([A-Z_]+)>/g, ({ matches }) => {
+ *   switch(matches?.[1]) {
+ *     default: return "<UNKNOWN_PATTERN>";
+ *     // these would be grabbed from elsewhere in the application:
+ *     case "USERNAME": return "JohnDoe45";
+ *     case "UNREAD_NOTIFS": return 5;
+ *   }
+ * });
+ *
+ * // replace <c=red>...</c> with <span class="color red">...</span>
+ * tr.addTransform(/<c=([a-z]+)>(.*?)<\/c>/g, ({ matches }) => {
+ *   const color = matches?.[1];
+ *   const content = matches?.[2];
+ *
+ *   return "<span class=\"color " + color + "\">" + content + "</span>";
+ * });
+ *
+ * tr.setLanguage("en");
+ *
+ * tr("greeting.with_username"); // "Hello, JohnDoe45"
+ * tr("greeting.headline"); // "<b>Hello, JohnDoe45</b>\nYou have 5 unread notifications."
+ * ```
+ * @param args A tuple containing the regular expression to match and the transform function to call if the pattern is found in a translation string
+ */
+declare function addTransform<TTrKey extends string = string>(transform: TransformTuple<TTrKey>): void;
+/**
+ * Deletes the first transform function from the list of registered transform functions.
+ * @param patternOrFn A reference to the regular expression of the transform function, a string matching the original pattern, or a reference to the transform function to delete
+ * @returns Returns true if the transform function was found and deleted, false if it wasn't found
+ */
+declare function deleteTransform(patternOrFn: RegExp | string | TransformFn): boolean;
+declare const tr: {
+    for: <TTrKey extends string = string>(language: string, key: TTrKey, ...args: (Stringifiable | Record<string, Stringifiable>)[]) => string;
+    use: <TTrKey extends string = string>(language: string) => (key: TTrKey, ...args: (Stringifiable | Record<string, Stringifiable>)[]) => string;
+    hasKey: <TTrKey extends string = string>(language: string | undefined, key: TTrKey) => boolean;
+    addTranslations: typeof addTranslations;
+    getTranslations: typeof getTranslations;
+    deleteTranslations: (language: string) => boolean;
+    setFallbackLanguage: typeof setFallbackLanguage;
+    getFallbackLanguage: typeof getFallbackLanguage;
+    addTransform: typeof addTransform;
+    deleteTransform: typeof deleteTransform;
+    transforms: {
+        templateLiteral: [RegExp, ({ matches, trArgs, trValue }: TransformFnProps<string>) => string];
+        percent: [RegExp, ({ matches, trArgs, trValue }: TransformFnProps<string>) => string];
+    };
+};
 export { tr };

package/dist/lib/types.d.ts CHANGED Viewed

@@ -1,23 +1,25 @@
 /** Represents any value that is either a string itself or can be converted to one (implicitly and explicitly) because it has a toString() method */
 export type Stringifiable = string | {
     toString(): string;
-};
+} | {
+    [Symbol.toStringTag]: string;
+} | number | boolean | null | undefined;
 /**
- * A type that offers autocomplete for the passed union but also allows any arbitrary value of the same type to be passed.
- * Supports unions of strings, numbers and objects.
+ * A type that offers autocomplete for the passed union but also allows any arbitrary value of the same type to be passed.
+ * Supports unions of strings, numbers and objects.
  */
 export type LooseUnion<TUnion extends string | number | object> = (TUnion) | (TUnion extends string ? (string & {}) : (TUnion extends number ? (number & {}) : (TUnion extends Record<keyof any, unknown> ? (object & {}) : never)));
 /**
- * A type that allows all strings except for empty ones
- * @example
- * function foo<T extends string>(bar: NonEmptyString<T>) {
- *   console.log(bar);
- * }
+ * A type that allows all strings except for empty ones
+ * @example
+ * function foo<T extends string>(bar: NonEmptyString<T>) {
+ *   console.log(bar);
+ * }
  */
 export type NonEmptyString<TString extends string> = TString extends "" ? never : TString;
 /**
- * Makes the structure of a type more readable by expanding it.
- * This can be useful for debugging or for improving the readability of complex types.
+ * Makes the structure of a type more readable by expanding it.
+ * This can be useful for debugging or for improving the readability of complex types.
  */
 export type Prettify<T> = {
     [K in keyof T]: T[K];

package/package.json CHANGED Viewed

@@ -1,38 +1,20 @@
 {
   "name": "@sv443-network/userutils",
   "libName": "UserUtils",
-  "version": "8.3.3",
-  "description": "Library with various utilities for userscripts - register listeners for when CSS selectors exist, intercept events, create persistent & synchronous data stores, modify the DOM more easily and more",
+  "version": "9.0.0",
+  "description": "Lightweight library with various utilities for userscripts - register listeners for when CSS selectors exist, intercept events, create persistent & synchronous data stores, modify the DOM more easily and much more",
   "main": "dist/index.js",
   "module": "dist/index.js",
   "types": "dist/lib/index.d.ts",
   "exports": {
     ".": {
-      "import": "./dist/index.js",
-      "require": "./dist/index.cjs",
       "browser": "./dist/index.global.js",
-      "types": "./dist/lib/index.d.ts"
+      "types": "./dist/lib/index.d.ts",
+      "require": "./dist/index.cjs",
+      "import": "./dist/index.js"
     }
   },
   "type": "module",
-  "scripts": {
-    "lint": "tsc --noEmit && eslint .",
-    "build-types": "tsc --emitDeclarationOnly --declaration --outDir dist",
-    "build-common": "tsup lib/index.ts --format cjs,esm --clean --treeshake",
-    "build-all": "tsup lib/index.ts --format cjs,esm,iife --treeshake --onSuccess \"npm run build-types && npm run post-build-global && echo Finished building.\"",
-    "build": "npm run build-common -- && npm run build-types",
-    "post-build-global": "npm run node-ts -- ./tools/post-build-global.mts",
-    "dev": "npm run build-common -- --sourcemap --watch --onSuccess \"npm run build-types && echo Finished building.\"",
-    "dev-all": "npm run build-all -- --watch",
-    "update-jsr-version": "npm run node-ts -- ./tools/update-jsr-version.mts",
-    "publish-package": "changeset publish",
-    "publish-package-jsr": "npm run update-jsr-version && npx jsr publish --allow-dirty",
-    "change": "changeset",
-    "node-ts": "node --no-warnings=ExperimentalWarning --enable-source-maps --loader ts-node/esm",
-    "test-serve": "npm run node-ts -- ./test/TestPage/server.mts",
-    "test-dev": "cd test/TestScript && npm run dev",
-    "test": "concurrently \"npm run test-serve\" \"npm run test-dev\""
-  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/Sv443-Network/UserUtils.git"
@@ -51,32 +33,55 @@
   },
   "homepage": "https://github.com/Sv443-Network/UserUtils",
   "dependencies": {
-    "nanoevents": "^9.0.0"
+    "nanoevents": "^9.1.0"
   },
   "devDependencies": {
-    "@changesets/cli": "^2.26.2",
-    "@types/express": "^4.17.19",
-    "@types/greasemonkey": "^4.0.4",
-    "@types/node": "^20.5.9",
-    "@typescript-eslint/eslint-plugin": "^6.2.1",
-    "@typescript-eslint/parser": "^6.2.1",
-    "concurrently": "^8.2.1",
-    "eslint": "^8.46.0",
-    "express": "^4.18.2",
-    "ts-node": "^10.9.1",
-    "tslib": "^2.6.1",
-    "tsup": "^7.1.0",
-    "typescript": "^5.1.6"
+    "@changesets/cli": "^2.27.11",
+    "@eslint/eslintrc": "^3.2.0",
+    "@types/express": "^4.17.21",
+    "@types/greasemonkey": "^4.0.7",
+    "@types/node": "^22.10.5",
+    "@types/tx2": "^1.0.3",
+    "@typescript-eslint/eslint-plugin": "^8.21.0",
+    "@typescript-eslint/parser": "^8.21.0",
+    "@typescript-eslint/utils": "^8.21.0",
+    "concurrently": "^8.2.2",
+    "eslint": "^9.18.0",
+    "express": "^4.21.2",
+    "globals": "^15.14.0",
+    "kleur": "^4.1.5",
+    "tslib": "^2.8.1",
+    "tsup": "^8.3.5",
+    "tsx": "^4.19.2",
+    "typescript": "^5.7.3"
   },
   "files": [
     "/dist/index.js",
     "/dist/index.cjs",
     "/dist/index.mjs",
     "/dist/index.global.js",
+    "/dist/index.umd.js",
     "/dist/lib/**.d.ts",
     "/package.json",
-    "/README.md",
+    "/README-summary.md",
     "/CHANGELOG.md",
     "/LICENSE.txt"
-  ]
+  ],
+  "scripts": {
+    "lint": "eslint . && tsc --noEmit",
+    "build-types": "tsc --emitDeclarationOnly --declaration --outDir dist && node --import tsx ./tools/fix-dts.mts",
+    "build-common": "tsup lib/index.ts --format cjs,esm --clean --treeshake",
+    "build-all": "tsup lib/index.ts --format cjs,esm,iife --treeshake --onSuccess \"pnpm build-types && pnpm post-build-global\"",
+    "build": "pnpm build-common -- && pnpm build-types",
+    "post-build-global": "node --import tsx ./tools/post-build-global.mts",
+    "dev": "pnpm build-common -- --sourcemap --watch --onSuccess \"pnpm build-types\"",
+    "dev-all": "pnpm build-all -- --watch",
+    "update-jsr-version": "node --import tsx ./tools/update-jsr-version.mts",
+    "publish-package": "changeset publish",
+    "publish-package-jsr": "pnpm update-jsr-version && npx jsr publish --allow-dirty",
+    "change": "changeset",
+    "test-serve": "node --import tsx ./test/TestPage/server.mts",
+    "test-dev": "cd test/TestScript && pnpm dev",
+    "test": "concurrently \"pnpm test-serve\" \"pnpm test-dev\""
+  }
 }