@7h3laughingman/foundry-helpers 13.351.0

package/LICENSE.MD

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 7H3LaughingMan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,3 @@
+[![GitHub License](https://img.shields.io/github/license/7H3LaughingMan/foundry-helpers)](https://github.com/7H3LaughingMan/foundry-helpers/blob/v13/LICENSE.MD)
+[![NPM Version](https://img.shields.io/npm/v/%407h3laughingman%2Ffoundry-helpers)](https://www.npmjs.com/package/@7h3laughingman/foundry-helpers)
+[![NPM Downloads](https://img.shields.io/npm/dw/%407h3laughingman%2Ffoundry-helpers)](https://www.npmjs.com/package/@7h3laughingman/foundry-helpers)

package/dist/lib-wrapper/index.d.ts

@@ -0,0 +1,348 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/no-unsafe-function-type */
+export {};
+
+declare global {
+    enum WRAPPER_TYPES {
+        "WRAPPER" = 1,
+        "MIXED" = 2,
+        "OVERRIDE" = 3,
+        "LISTENER" = 4
+    }
+
+    enum PERF_MODES {
+        "NORMAL" = 1,
+        "AUTO" = 2,
+        "FAST" = 3
+    }
+
+    type WrapperType = "WRAPPER" | "MIXED" | "OVERRIDE" | "LISTENER" | WRAPPER_TYPES;
+    type PerfomanceModes = "NORMAL" | "FAST" | "AUTO" | PERF_MODES;
+
+    export class libWrapper {
+        /**
+         * Get libWrapper version
+         * @returns libWrapper version in string form, i.e. "<MAJOR>.<MINOR>.<PATCH>.<SUFFIX><META>"
+         */
+        static get version(): string;
+
+        /**
+         * Get libWrapper version
+         * @returns libWrapper version in array form, i.e. [<MAJOR>, <MINOR>, <PATCH>, <SUFFIX>, <META>]
+         */
+        static get versions(): [number, number, number, number, string];
+
+        /**
+         * Get the Git version identifier.
+         * @returns Git version identifier, usually 'HEAD' or the commit hash.
+         */
+        static get git_version(): string;
+
+        /**
+         * @returns The real libWrapper module will always return false. Fallback implementations (e.g. poly-fill / shim) should return true.
+         */
+        static get is_fallback(): boolean;
+
+        // Errors
+        static get LibWrapperError(): Error;
+        static get Error(): Error;
+
+        static get LibWrapperInternalError(): Error;
+        static get InternalError(): Error;
+
+        static get LibWrapperPackageError(): Error;
+        static get PackageError(): Error;
+
+        static get LibWrapperAlreadyOverriddenError(): Error;
+        static get AlreadyOverriddenError(): Error;
+
+        static get LibWrapperInvalidWrapperChainError(): Error;
+        static get InvalidWrapperChainError(): Error;
+
+        // Enums - First introduced in v1.9.0.0
+        static get WRAPPER(): WRAPPER_TYPES.WRAPPER;
+        static get MIXED(): WRAPPER_TYPES.MIXED;
+        static get OVERRIDE(): WRAPPER_TYPES.OVERRIDE;
+        static get LISTENER(): WRAPPER_TYPES.LISTENER;
+
+        static get PERF_NORMAL(): PERF_MODES.NORMAL;
+        static get PERF_AUTO(): PERF_MODES.AUTO;
+        static get PERF_FAST(): PERF_MODES.FAST;
+
+        // Methods
+        /**
+         * Test for a minimum libWrapper version.
+         * First introduced in v1.4.0.0.
+         *
+         * @param major Minimum major version
+         * @param minor Minimum minor version. Default is 0.
+         * @param patch Minimum patch version. Default is 0.
+         * @param suffix Minimum suffix version. Default is 0.
+         * @returns Returns true if the libWrapper version is at least the queried version, otherwise false.
+         */
+        static version_at_least(major: number, minor?: number, patch?: number, suffix?: number): boolean;
+
+        /**
+         * Register a new wrapper.
+         * Important: If called before the 'init' hook, this method will fail.
+         *
+         * In addition to wrapping class methods, there is also support for wrapping methods on specific object instances, as well as class methods inherited from parent classes.
+         * However, it is recommended to wrap methods directly in the class that defines them whenever possible, as inheritance/instance wrapping is less thoroughly tested and will incur a performance penalty.
+         *
+         * Triggers FVTT hook 'libWrapper.Register' when successful.
+         *
+         * Returns a unique numeric target identifier, which can be used as a replacement for 'target' in future calls to 'libWrapper.register' and 'libWrapper.unregister'.
+         *
+         * @param package_id The package identifier, i.e. the 'id' field in your module/system/world's manifest.
+         *
+         * @param target The target identifier, specifying which wrapper should be registered.
+         *
+         *   This can be either:
+         *     1. A unique target identifier obtained from a previous 'libWrapper.register' call.
+         *     2. A string containing the path to the function you wish to add the wrapper to, starting at global scope, for example 'SightLayer.prototype.updateToken'.
+         *
+         *   Support for the unique target identifiers (option #1) was added in v1.11.0.0, with previous versions only supporting option #2.
+         *
+         *   Since v1.8.0.0, the string path (option #2) can contain string array indexing.
+         *   For example, 'CONFIG.Actor.sheetClasses.character["dnd5e.ActorSheet5eCharacter"].cls.prototype._onLongRest' is a valid path.
+         *   It is important to note that indexing in libWrapper does not work exactly like in JavaScript:
+         *     - The index must be a single string, quoted using the ' or " characters. It does not support e.g. numbers or objects.
+         *     - A backslash \ can be used to escape another character so that it loses its special meaning, e.g. quotes i.e. ' and " as well as the character \ itself.
+         *
+         *   By default, libWrapper searches for normal methods or property getters only. To wrap a property's setter, append '#set' to the name, for example 'SightLayer.prototype.blurDistance#set'.
+         *
+         * @param fn Wrapper function. The first argument will be the next function in the chain, except for 'OVERRIDE' wrappers.
+         *   The remaining arguments will correspond to the parameters passed to the wrapped method.
+         *
+         * @param type The type of the wrapper. Default is 'MIXED'.
+         *
+         *   The possible types are:
+         *
+         *   'LISTENER' / libWrapper.LISTENER:
+         * 	   Use this to register a listener function. This function will be called immediately before the target is called, but is not part of the call chain.
+         *     Use when you just need to know a method is being called and the parameters used for the call, without needing to modify the parameters or execute any
+         *     code after the method finishes execution.
+         *     Listeners will always be called first, before any other type, and should be used whenever possible as they have a virtually zero chance of conflict.
+         *     Note that asynchronous listeners are *not* awaited before execution is allowed to proceed.
+         *     First introduced in v1.13.0.0.
+         *
+         *   'WRAPPER' / libWrapper.WRAPPER:
+         *     Use if your wrapper will *always* continue the chain.
+         *     This type has priority over MIXED and OVERRIDE. It should be preferred over those whenever possible as it massively reduces the likelihood of conflicts.
+         *     Note that the library will auto-detect if you use this type but do not call the original function, and automatically unregister your wrapper.
+         *
+         *   'MIXED' / libWrapper.MIXED:
+         *     Default type. Your wrapper will be allowed to decide whether it continue the chain or not.
+         *     These will always come after 'WRAPPER'-type wrappers. Order is not guaranteed, but conflicts will be auto-detected.
+         *
+         *   'OVERRIDE' / libWrapper.OVERRIDE:
+         *     Use if your wrapper will *never* continue the chain. This type has the lowest priority, and will always be called last.
+         *     If another package already has an 'OVERRIDE' wrapper registered to the same method, using this type will throw a <libWrapper.ERRORS.package> exception.
+         *     Catching this exception should allow you to fail gracefully, and for example warn the user of the conflict.
+         *     Note that if the GM has explicitly given your package priority over the existing one, no exception will be thrown and your wrapper will take over.
+         *
+         * @param options Additional options to libWrapper.
+         *
+         * @param options.chain If 'true', the first parameter to 'fn' will be a function object that can be called to continue the chain.
+         *   This parameter must be 'true' when registering non-OVERRIDE wrappers.
+         *   Default is 'false' if type=='OVERRIDE', otherwise 'true'.
+         *   First introduced in v1.3.6.0.
+         *
+         * @param options.perf_mode Selects the preferred performance mode for this wrapper. Default is 'AUTO'.
+         *   It will be used if all other wrappers registered on the same target also prefer the same mode, otherwise the default will be used instead.
+         *   This option should only be specified with good reason. In most cases, using 'AUTO' in order to allow the GM to choose is the best option.
+         *   First introduced in v1.5.0.0.
+         *
+         *   The possible modes are:
+         *
+         *   'NORMAL' / libWrapper.PERF_NORMAL:
+         *     Enables all conflict detection capabilities provided by libWrapper. Slower than 'FAST'.
+         *     Useful if wrapping a method commonly modified by other packages, to ensure most issues are detected.
+         *     In most other cases, this mode is not recommended and 'AUTO' should be used instead.
+         *
+         *   'FAST' / libWrapper.PERF_FAST:
+         *     Disables some conflict detection capabilities provided by libWrapper, in exchange for performance. Faster than 'NORMAL'.
+         *     Will guarantee wrapper call order and per-package prioritization, but fewer conflicts will be detectable.
+         *     This performance mode will result in comparable performance to traditional non-libWrapper wrapping methods.
+         *     Useful if wrapping a method called repeatedly in a tight loop, for example 'WallsLayer.testWall'.
+         *     In most other cases, this mode is not recommended and 'AUTO' should be used instead.
+         *
+         *   'AUTO' / libWrapper.PERF_AUTO:
+         *     Default performance mode. If unsure, choose this mode.
+         *     Will allow the GM to choose which performance mode to use.
+         *     Equivalent to 'FAST' when the libWrapper 'High-Performance Mode' setting is enabled by the GM, otherwise 'NORMAL'.
+         *
+         * @param options.bind An array of parameters that should be passed to 'fn'.
+         *
+         *   This allows avoiding an extra function call, for instance:
+         *     libWrapper.register(PACKAGE_ID, "foo", function(wrapped, ...args) { return someFunction.call(this, wrapped, "foo", "bar", ...args) });
+         *   becomes
+         *     libWrapper.register(PACKAGE_ID, "foo", someFunction, "WRAPPER", {bind: ["foo", "bar"]});
+         *
+         *   First introduced in v1.12.0.0.
+         *
+         * @returns Unique numeric 'target' identifier which can be used in future 'libWrapper.register' and 'libWrapper.unregister' calls.
+         *   Added in v1.11.0.0.
+         */
+        static register(
+            package_id: string,
+            target: number | string,
+            fn: Function,
+            type?: WRAPPER_TYPES,
+            options?: {
+                chain?: boolean;
+                perf_mode?: PerfomanceModes;
+                bind?: unknown[];
+            }
+        ): number;
+        static register<T extends ThisType<F>, F extends (...args: any) => any>(
+            package_id: string,
+            target: number | string,
+            fn: (this: T, wrapped: F, ...args: Parameters<F>) => ReturnType<F>,
+            type?: WRAPPER_TYPES.WRAPPER | WRAPPER_TYPES.MIXED | "WRAPPER" | "MIXED",
+            options?: {
+                chain?: boolean;
+                perf_mode?: PerfomanceModes;
+                bind?: unknown[];
+            }
+        ): number;
+        static register<T extends ThisType<F>, F extends (...args: any) => any>(
+            package_id: string,
+            target: number | string,
+            fn: (this: T, ...args: Parameters<F>) => ReturnType<F>,
+            type?: WRAPPER_TYPES.OVERRIDE | "OVERRIDE",
+            options?: {
+                chain?: boolean;
+                perf_mode?: PerfomanceModes;
+                bind?: unknown[];
+            }
+        ): number;
+        static register<T extends ThisType<F>, F extends (...args: any) => any>(
+            package_id: string,
+            target: number | string,
+            fn: (this: T, ...args: Parameters<F>) => void | Promise<void>,
+            type?: WRAPPER_TYPES.LISTENER | "LISTENER",
+            options?: {
+                chain?: boolean;
+                perf_mode?: PerfomanceModes;
+                bind?: unknown[];
+            }
+        ): number;
+
+        /**
+         * Unregister an existing wrapper.
+         *
+         * Triggers FVTT hook 'libWrapper.Unregister' when successful.
+         *
+         * @param package_id The package identifier, i.e. the 'id' field in your module/system/world's manifest.
+         *
+         * @param target The target identifier, specifying which wrapper should be unregistered.
+         *
+         *   This can be either:
+         *     1. A unique target identifier obtained from a previous 'libWrapper.register' call. This is the recommended option.
+         *     2. A string containing the path to the function you wish to remove the wrapper from, starting at global scope, with the same syntax as the 'target' parameter to 'libWrapper.register'.
+         *
+         *   Support for the unique target identifiers (option #1) was added in v1.11.0.0, with previous versions only supporting option #2.
+         *   It is recommended to use option #1 if possible, in order to guard against the case where the class or object at the given path is no longer the same as when `libWrapper.register' was called.
+         *
+         * @param fail If true, this method will throw an exception if it fails to find the method to unwrap. Default is 'true'.
+         */
+        static unregister(package_id: string, target: number | string, fail?: boolean): void;
+
+        /**
+         * Unregister all wrappers created by a given package.
+         *
+         * Triggers FVTT hook 'libWrapper.UnregisterAll' when successful.
+         *
+         * @param package_id The package identifier, i.e. the 'id' field in your module/system/world's manifest.
+         */
+        static unregister_all(package_id: string): void;
+
+        /**
+         * Ignore conflicts matching specific filters when detected, instead of warning the user.
+         *
+         * This can be used when there are conflict warnings that are known not to cause any issues, but are unable to be resolved.
+         * Conflicts will be ignored if they involve both 'package_id' and one of 'ignore_ids', and relate to one of 'targets'.
+         *
+         * Note that the user can still see which detected conflicts were ignored, by toggling "Show ignored conflicts" in the "Conflicts" tab in the libWrapper settings.
+         *
+         * First introduced in v1.7.0.0.
+         *
+         * @param package_id The package identifier, i.e. the 'id' field in your module/system/world's manifest. This will be the package that owns this ignore entry.
+         *
+         * @param ignore_ids Other package ID(s) with which conflicts should be ignored.
+         *
+         * @param targets Target(s) for which conflicts should be ignored, corresponding to the 'target' parameter to 'libWrapper.register'.
+         *   This method does not accept the unique target identifiers returned by 'libWrapper.register'.
+         *
+         * @param options Additional options to libWrapper.
+         *
+         * @param options.ignore_errors If 'true', will also ignore confirmed conflicts (i.e. errors), rather than only potential conflicts (i.e. warnings).
+         *   Be careful when setting this to 'true', as confirmed conflicts are almost certainly something the user should be made aware of.
+         *   Defaults to 'false'.
+         */
+        static ignore_conflicts(package_id: string, ignore_ids: string | string[], targets: string | string[], options?: { ingore_errors?: boolean }): void;
+    }
+}
+
+declare module "foundry-types/client/helpers/hooks.mjs" {
+    namespace Hooks {
+        function on(hook: "libWrapper.Ready", callback: () => boolean | void | Promise<boolean | void>): number;
+        function on(
+            hook: "libWrapper.Register",
+            callback: (
+                package_id: string,
+                target: number | string,
+                type: WRAPPER_TYPES,
+                options: {
+                    chain?: boolean;
+                    perf_mode?: PerfomanceModes;
+                    bind?: unknown[];
+                },
+                wrapper_id: number
+            ) => boolean | void | Promise<boolean | void>
+        ): number;
+        function on(
+            hook: "libWrapper.Unregister",
+            callback: (package_id: string, target: number | string, wrapper_id: number) => boolean | void | Promise<boolean | void>
+        ): number;
+        function on(hook: "libWrapper.UnregisterAll", callback: (package_id: string) => boolean | void | Promise<boolean | void>): number;
+        function on(
+            hook: "libWrapper.ConflictDetected",
+            callback: (package_id: string, other_info: string, target: string, frozen_names: string[]) => boolean | void | Promise<boolean | void>
+        ): number;
+        function on(
+            hook: "libWrapper.OverrideLost",
+            callback: (package_id: string, other_info: string, target: string, frozen_names: string[]) => boolean | void | Promise<boolean | void>
+        ): number;
+
+        function once(hook: "libWrapper.Ready", callback: () => boolean | void | Promise<boolean | void>): number;
+        function once(
+            hook: "libWrapper.Register",
+            callback: (
+                package_id: string,
+                target: number | string,
+                type: WRAPPER_TYPES,
+                options: {
+                    chain?: boolean;
+                    perf_mode?: PerfomanceModes;
+                    bind?: unknown[];
+                },
+                wrapper_id: number
+            ) => boolean | void | Promise<boolean | void>
+        ): number;
+        function once(
+            hook: "libWrapper.Unregister",
+            callback: (package_id: string, target: number | string, wrapper_id: number) => boolean | void | Promise<boolean | void>
+        ): number;
+        function once(hook: "libWrapper.UnregisterAll", callback: (package_id: string) => boolean | void | Promise<boolean | void>): number;
+        function once(
+            hook: "libWrapper.ConflictDetected",
+            callback: (package_id: string, other_info: string, target: string, frozen_names: string[]) => boolean | void | Promise<boolean | void>
+        ): number;
+        function once(
+            hook: "libWrapper.OverrideLost",
+            callback: (package_id: string, other_info: string, target: string, frozen_names: string[]) => boolean | void | Promise<boolean | void>
+        ): number;
+    }
+}

package/dist/utilities/array.d.ts

@@ -0,0 +1,12 @@
+export declare class CycleArray<T> extends Array<T> {
+    #private;
+    get index(): number;
+    get current(): T;
+    get isLast(): boolean;
+    get isFirst(): boolean;
+    setFromValue(value: T): void;
+    increment(): T;
+    decrement(): T;
+    cycle(direction: number | boolean): T;
+}
+export declare function includesAny(array: unknown[], entries: unknown[]): boolean;

package/dist/utilities/array.js

@@ -0,0 +1,40 @@
+export class CycleArray extends Array {
+    #index = 0;
+    get index() {
+        if (this.#index > this.length - 1)
+            this.#index = this.length - 1;
+        return this.#index;
+    }
+    get current() {
+        return this.at(this.index);
+    }
+    get isLast() {
+        return this.index === this.length - 1;
+    }
+    get isFirst() {
+        return this.index === 0;
+    }
+    setFromValue(value) {
+        const index = this.indexOf(value);
+        this.#index = index >= 0 ? index : this.#index;
+    }
+    increment() {
+        this.#index = (this.index + 1) % this.length;
+        return this.current;
+    }
+    decrement() {
+        const modulo = this.length;
+        const value = this.index - 1;
+        this.#index = ((value % modulo) + modulo) % modulo;
+        return this.current;
+    }
+    cycle(direction) {
+        return Number(direction) > 0 ? this.increment() : this.decrement();
+    }
+}
+export function includesAny(array, entries) {
+    for (const entry of entries)
+        if (array.includes(entry))
+            return true;
+    return false;
+}

package/dist/utilities/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./array.js";
+export * from "./localize.js";
+export * from "./module.js";
+export * from "./settings.js";
+export * from "./time.js";
+export * from "./user.js";

package/dist/utilities/index.js

@@ -0,0 +1,6 @@
+export * from "./array.js";
+export * from "./localize.js";
+export * from "./module.js";
+export * from "./settings.js";
+export * from "./time.js";
+export * from "./user.js";

package/dist/utilities/localize.d.ts

@@ -0,0 +1,25 @@
+declare class Localize extends Function {
+    subkeys: string[];
+    constructor(...subkeys: string[]);
+    path(...path: string[]): string;
+    getLocalizeData(...args: LocalizeArgs): {
+        path: string;
+        data?: LocalizeData;
+    };
+    localizeOrFormat(path: string, data?: LocalizeData): string;
+    ifExist(...args: LocalizeArgs): string | undefined;
+    notify(type: "info" | "warning" | "error" | "success", ...args: NotificationArgs): foundry.applications.ui.Notification;
+    info(...args: NotificationArgs): foundry.applications.ui.Notification;
+    warning(...args: NotificationArgs): foundry.applications.ui.Notification;
+    error(...args: NotificationArgs): foundry.applications.ui.Notification;
+    success(...args: NotificationArgs): foundry.applications.ui.Notification;
+    sub(...subkeys: string[]): Localize;
+}
+interface Localize {
+    (...args: LocalizeArgs): string;
+}
+export declare const localize: Localize;
+export type LocalizeData = Record<string, Maybe<string | number | boolean>>;
+export type LocalizeArgs = string[] | [...string[], string | LocalizeData];
+export type NotificationArgs = LocalizeArgs | [...LocalizeArgs, string | LocalizeData | boolean];
+export type { Localize };

package/dist/utilities/localize.js

@@ -0,0 +1,56 @@
+import * as R from "remeda";
+import { MODULE } from "./module.js";
+// eslint-disable-next-line @typescript-eslint/no-unsafe-declaration-merging
+class Localize extends Function {
+    constructor(...subkeys) {
+        super();
+        this.subkeys = subkeys;
+        const self = this;
+        function localize(...args) {
+            const { data, path } = self.getLocalizeData(...args);
+            return self.localizeOrFormat(path, data);
+        }
+        Object.assign(localize, this);
+        Object.setPrototypeOf(localize, Object.getPrototypeOf(this));
+        return localize;
+    }
+    path(...path) {
+        return MODULE.path(...this.subkeys, ...path);
+    }
+    getLocalizeData(...args) {
+        const data = R.isObjectType(args.at(-1)) ? args.pop() : undefined;
+        const path = this.path(...args);
+        return { path, data };
+    }
+    localizeOrFormat(path, data) {
+        return typeof data === "object" ? game.i18n.format(path, data) : game.i18n.localize(path);
+    }
+    ifExist(...args) {
+        const { data, path } = this.getLocalizeData(...args);
+        if (game.i18n.has(path, true)) {
+            return this.localizeOrFormat(path, data);
+        }
+        return undefined;
+    }
+    notify(type, ...args) {
+        const permanent = R.isBoolean(args.at(-1)) ? args.pop() : false;
+        const message = this(...args);
+        return foundry.ui.notifications.notify(message, type, { permanent });
+    }
+    info(...args) {
+        return this.notify("info", ...args);
+    }
+    warning(...args) {
+        return this.notify("warning", ...args);
+    }
+    error(...args) {
+        return this.notify("error", ...args);
+    }
+    success(...args) {
+        return this.notify("success", ...args);
+    }
+    sub(...subkeys) {
+        return new Localize(...this.subkeys, ...subkeys);
+    }
+}
+export const localize = new Localize();

package/dist/utilities/module.d.ts

@@ -0,0 +1,21 @@
+import { Module } from "@7h3laughingman/foundry-types/client/packages/_module.mjs";
+import { ImageFilePath } from "@7h3laughingman/foundry-types/common/constants.mjs";
+declare class CustomModule {
+    #private;
+    get id(): string;
+    get current(): Module;
+    get name(): string;
+    get isDebug(): boolean;
+    register(id: string, globalName?: string): void;
+    globalPath(...path: string[]): string;
+    path(...path: string[]): string;
+    relativePath(...path: string[]): string;
+    imagePath(...path: [...string[], ImageFilePath]): ImageFilePath;
+    templatePath(...path: [...string[], `${string}.hbs`]): string;
+    Error(message: string): Error;
+    error(input: string, error?: unknown): void;
+    apiExpose(key: string, toExpose: Record<string, unknown>): void;
+    debugExpose(key: string, toExpose: unknown): void;
+}
+export declare const MODULE: CustomModule;
+export {};

package/dist/utilities/module.js

@@ -0,0 +1,130 @@
+import * as R from "remeda";
+import { localize } from "./localize.js";
+import { getSetting } from "./settings.js";
+class CustomModule {
+    #api = {};
+    #current;
+    #debug = {};
+    #globalName = "";
+    #id;
+    get id() {
+        if (!this.#id)
+            throw new Error("Module needs to be registered.");
+        return this.#id;
+    }
+    get current() {
+        return (this.#current ??= game.modules.get(this.id));
+    }
+    get name() {
+        return this.current.title;
+    }
+    get isDebug() {
+        return foundry.utils.getProperty(CONFIG, `debug.${this.id}`) === true;
+    }
+    register(id, globalName) {
+        if (this.#id)
+            throw new Error("Module has already been registered.");
+        this.#id = id;
+        this.#globalName = globalName || id.replace(/-(\w)/g, (_, p1) => p1.toUpperCase());
+        Hooks.once("init", () => {
+            const self = this;
+            const context = {};
+            Object.defineProperties(context, {
+                active: {
+                    get() {
+                        return self.current.active;
+                    },
+                    configurable: false,
+                    enumerable: false
+                },
+                api: {
+                    get() {
+                        return self.#api;
+                    },
+                    configurable: false,
+                    enumerable: false
+                },
+                debug: {
+                    get() {
+                        return self.#debug;
+                    },
+                    configurable: false,
+                    enumerable: false
+                },
+                getSetting: {
+                    value: function (setting) {
+                        return self.current.active ? getSetting(setting) : undefined;
+                    },
+                    writable: false,
+                    configurable: false,
+                    enumerable: false
+                },
+                localize: {
+                    value: localize.sub(id),
+                    configurable: false,
+                    enumerable: false,
+                    writable: false
+                }
+            });
+            Object.defineProperty(game, this.#globalName, {
+                value: context,
+                configurable: false,
+                enumerable: false,
+                writable: false
+            });
+        });
+    }
+    globalPath(...path) {
+        return `${this.#globalName}.${R.join(path, ".")}`;
+    }
+    path(...path) {
+        return `${this.id}.${R.join(path, ".")}`;
+    }
+    relativePath(...path) {
+        return `modules/${this.id}/${R.join(path, "/")}`;
+    }
+    imagePath(...path) {
+        return this.relativePath(...path);
+    }
+    templatePath(...path) {
+        return this.relativePath(...path);
+    }
+    Error(message) {
+        return new Error(`\n[${this.name}] ${message}`);
+    }
+    error(input, error) {
+        let message = `[${this.name}] ${input}`;
+        if (error instanceof Error) {
+            message += `\n${error.message}`;
+        }
+        else if (typeof error === "string") {
+            message += `\n${error}`;
+        }
+        console.error(message);
+    }
+    apiExpose(key, toExpose) {
+        if (foundry.utils.hasProperty(this.#api, key))
+            throw this.Error(`The API key "${key}" has already been defined.`);
+        const exposed = foundry.utils.deepClone(toExpose);
+        Object.freeze(exposed);
+        Object.defineProperty(this.#api, key, {
+            value: exposed,
+            configurable: false,
+            enumerable: false,
+            writable: false
+        });
+    }
+    debugExpose(key, toExpose) {
+        if (foundry.utils.hasProperty(this.#debug, key))
+            throw this.Error(`The debug key "${key}" has already been defined.`);
+        const exposed = foundry.utils.deepClone(toExpose);
+        Object.freeze(exposed);
+        Object.defineProperty(this.#debug, key, {
+            value: exposed,
+            configurable: false,
+            enumerable: false,
+            writable: false
+        });
+    }
+}
+export const MODULE = new CustomModule();

package/dist/utilities/settings.d.ts

@@ -0,0 +1,3 @@
+export declare function settingPath(...path: string[]): string;
+export declare function getSetting<T = unknown>(key: string): T;
+export declare function setSetting<T = unknown>(key: string, value: T): Promise<T>;

package/dist/utilities/settings.js

@@ -0,0 +1,10 @@
+import { MODULE } from "./module.js";
+export function settingPath(...path) {
+    return MODULE.path("settings", ...path);
+}
+export function getSetting(key) {
+    return game.settings.get(MODULE.id, key);
+}
+export function setSetting(key, value) {
+    return game.settings.set(MODULE.id, key, value);
+}

package/dist/utilities/time.d.ts

@@ -0,0 +1 @@
+export declare function waitTimeout(delay?: number): Promise<void>;

package/dist/utilities/time.js

@@ -0,0 +1,5 @@
+export function waitTimeout(delay = 1) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, delay);
+    });
+}

package/dist/utilities/user.d.ts

@@ -0,0 +1,6 @@
+export declare function getCurrentUser(): User;
+export declare function userIsGM(user?: User): boolean;
+export declare function getPrimaryUpdater(actor: Actor): User | null;
+export declare function isPrimaryUpdater(actor: Actor, user?: User): boolean;
+export declare function primaryPlayerOwner(actor: Actor): User | null;
+export declare function isPrimaryOwner(actor: Actor, user?: User): boolean;

package/dist/utilities/user.js

@@ -0,0 +1,25 @@
+export function getCurrentUser() {
+    return game.user ?? game.data.users.find((value) => value._id === game.userId);
+}
+export function userIsGM(user = getCurrentUser()) {
+    return user && user.role >= CONST.USER_ROLES.ASSISTANT;
+}
+export function getPrimaryUpdater(actor) {
+    const { activeGM } = game.users;
+    if (activeGM)
+        return activeGM;
+    const primaryPlayer = actor.isToken ? null : game.users.getDesignatedUser((user) => user.active && user.character === actor);
+    if (primaryPlayer)
+        return primaryPlayer;
+    return game.users.getDesignatedUser((user) => actor.canUserModify(user, "update"));
+}
+export function isPrimaryUpdater(actor, user = getCurrentUser()) {
+    return getPrimaryUpdater(actor) === user;
+}
+export function primaryPlayerOwner(actor) {
+    const assigned = game.users.getDesignatedUser((user) => user.active && user.character === actor);
+    return assigned ?? game.users.getDesignatedUser((user) => user.active && !user.isGM && actor.testUserPermission(user, "OWNER"));
+}
+export function isPrimaryOwner(actor, user = getCurrentUser()) {
+    return user.isGM || primaryPlayerOwner(actor) === user;
+}

package/package.json

@@ -0,0 +1,48 @@
+{
+    "name": "@7h3laughingman/foundry-helpers",
+    "version": "13.351.0",
+    "description": "Basic helpers used for developing modules for Foundry VTT",
+    "homepage": "https://github.com/7H3LaughingMan/foundry-helpers#readme",
+    "bugs": {
+        "url": "https://github.com/7H3LaughingMan/foundry-helpers/issues"
+    },
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/7H3LaughingMan/foundry-helpers.git"
+    },
+    "license": "MIT",
+    "author": "7H3LaughingMan <7H3LaughingMan@proton.me> (https://github.com/7H3LaughingMan)",
+    "type": "module",
+    "exports": {
+        "./lib-wrapper": "./dist/lib-wrapper/index.d.ts",
+        "./utilities": "./dist/utilities/index.js"
+    },
+    "files": [
+        "./dist/*"
+    ],
+    "scripts": {
+        "tsc": "tsc",
+        "copy-dts": "copyfiles -u 1 \"src/**/*.d.ts\" dist",
+        "eslint": "eslint src",
+        "eslint:fix": "eslint src --fix && prettier src --write"
+    },
+    "dependencies": {
+        "@7h3laughingman/foundry-types": "~13.351",
+        "remeda": "^2.33.6"
+    },
+    "devDependencies": {
+        "@eslint/js": "^9.39.2",
+        "@eslint/json": "^0.14.0",
+        "copyfiles": "^2.4.1",
+        "eslint": "^9.39.2",
+        "eslint-config-prettier": "^10.1.8",
+        "eslint-plugin-prettier": "^5.5.5",
+        "prettier-plugin-organize-imports": "^4.3.0",
+        "typescript": "5.9.3",
+        "typescript-eslint": "^8.55.0"
+    },
+    "engines": {
+        "node": ">=24"
+    },
+    "sideEffects": false
+}