@7h3laughingman/foundry-helpers 13.351.0 → 13.351.1

package/dist/utilities/compendium-collection.d.ts

@@ -0,0 +1,10 @@
+import CompendiumCollection = foundry.documents.collections.CompendiumCollection;
+export declare function isCompendiumPack<T extends Actor<null>>(pack: unknown, type: "Actor"): pack is CompendiumCollection<T>;
+export declare function isCompendiumPack<T extends Adventure>(pack: unknown, type: "Adventure"): pack is CompendiumCollection<T>;
+export declare function isCompendiumPack<T extends Cards>(pack: unknown, type: "Cards"): pack is CompendiumCollection<T>;
+export declare function isCompendiumPack<T extends Item<null>>(pack: unknown, type: "Item"): pack is CompendiumCollection<T>;
+export declare function isCompendiumPack<T extends JournalEntry>(pack: unknown, type: "Item"): pack is CompendiumCollection<T>;
+export declare function isCompendiumPack<T extends Macro>(pack: unknown, type: "Macro"): pack is CompendiumCollection<T>;
+export declare function isCompendiumPack<T extends Playlist>(pack: unknown, type: "Playlist"): pack is CompendiumCollection<T>;
+export declare function isCompendiumPack<T extends RollTable>(pack: unknown, type: "RollTable"): pack is CompendiumCollection<T>;
+export declare function isCompendiumPack<T extends Scene>(pack: unknown, type: "Scene"): pack is CompendiumCollection<T>;

package/dist/utilities/compendium-collection.js

@@ -0,0 +1,5 @@
+import * as R from "remeda";
+var CompendiumCollection = foundry.documents.collections.CompendiumCollection;
+export function isCompendiumPack(pack, type) {
+    return R.isNonNullish(pack) && pack instanceof CompendiumCollection && pack.documentName === type;
+}

package/dist/utilities/flags.d.ts

@@ -0,0 +1,10 @@
+import Document = foundry.abstract.Document;
+export declare function getFlag<T>(document: Document, ...path: string[]): T | undefined;
+export declare function setFlag<TDocument extends Document, T>(document: TDocument, ...args: [...string[], T]): Promise<TDocument>;
+export declare function unsetFlag<TDocument extends Document>(document: TDocument, ...path: string[]): Promise<TDocument | undefined>;
+export declare function flagPath(...path: string[]): string;
+export declare function unsetFlagPath(...path: [string, ...string[]]): string;
+export declare function getFlagProperty<T>(object: object, ...path: string[]): T | undefined;
+export declare function setFlagProperty<TObject extends object, T>(object: TObject, ...args: [...string[], T]): TObject;
+export declare function unsetFlagProperty<TObject extends object>(object: TObject, ...path: [string, ...string[]]): TObject;
+export declare function deleteFlagProperty<TObject extends object>(object: TObject, ...path: string[]): TObject;

package/dist/utilities/flags.js

@@ -0,0 +1,35 @@
+import * as R from "remeda";
+import { MODULE } from "./module";
+export function getFlag(document, ...path) {
+    return document.getFlag(MODULE.id, R.join(path, "."));
+}
+export function setFlag(document, ...args) {
+    const value = args.pop();
+    return document.setFlag(MODULE.id, R.join(args, "."), value);
+}
+export function unsetFlag(document, ...path) {
+    return document.unsetFlag(MODULE.id, R.join(path, "."));
+}
+export function flagPath(...path) {
+    return `flags.${MODULE.path(...path)}`;
+}
+export function unsetFlagPath(...path) {
+    const lastKey = path.pop();
+    return flagPath(...path, `-=${lastKey}`);
+}
+export function getFlagProperty(object, ...path) {
+    return foundry.utils.getProperty(object, flagPath(...path));
+}
+export function setFlagProperty(object, ...args) {
+    const value = args.pop();
+    foundry.utils.setProperty(object, flagPath(...args), value);
+    return object;
+}
+export function unsetFlagProperty(object, ...path) {
+    foundry.utils.setProperty(object, unsetFlagPath(...path), null);
+    return object;
+}
+export function deleteFlagProperty(object, ...path) {
+    foundry.utils.deleteProperty(object, flagPath(...path));
+    return object;
+}

package/dist/utilities/html.d.ts

@@ -0,0 +1,51 @@
+/**  DOM helper functions that return HTMLElement(s) (or `null`) */
+type MaybeHTML = Maybe<Document | Element | EventTarget>;
+/**
+ * Create an `HTMLElement` with classes, dataset, and children
+ * @param nodeName  A valid HTML element tag name,
+ * @param options Additional options for adjusting the created element
+ * @param options.classes A list of class names
+ * @param options.dataset An object of keys and values with which to populate the `dataset`: nullish values and `false`
+ *                        will be excluded. A value of `true` will result in an empty-string value.
+ * @param options.aria An object of keys and values with which to populate the `dataset`: nullish values and `false`
+ *                     will be excluded.
+ * @param options.children A list of child elements as well as strings that will be converted to text nodes
+ * @param options.innerHTML A string to set as the inner HTML of the created element. Only one of `children` and
+ *                          `innerHTML` can be used.
+ * @returns The HTML element with all options applied
+ */
+export declare function createHTMLElement<K extends keyof HTMLElementTagNameMap>(nodeName: K, options?: CreateHTMLElementOptionsWithChildren): HTMLElementTagNameMap[K];
+export declare function createHTMLElement<K extends keyof HTMLElementTagNameMap>(nodeName: K, options?: CreateHTMLElementOptionsWithInnerHTML): HTMLElementTagNameMap[K];
+export declare function createHTMLElement<K extends keyof HTMLElementTagNameMap>(nodeName: K, options?: CreateHTMLElementOptionsWithNeither): HTMLElementTagNameMap[K];
+interface CreateHTMLElementOptions {
+    id?: string;
+    classes?: string[];
+    dataset?: Record<string, Maybe<string | number | boolean>>;
+    aria?: Record<string, Maybe<string | false>>;
+    children?: (HTMLElement | string)[];
+    innerHTML?: string;
+}
+interface CreateHTMLElementOptionsWithChildren extends CreateHTMLElementOptions {
+    children: (HTMLElement | string)[];
+    innerHTML?: never;
+}
+interface CreateHTMLElementOptionsWithInnerHTML extends CreateHTMLElementOptions {
+    children?: never;
+    innerHTML: string;
+}
+interface CreateHTMLElementOptionsWithNeither extends CreateHTMLElementOptions {
+    children?: never;
+    innerHTML?: never;
+}
+export declare function htmlQuery<K extends keyof HTMLElementTagNameMap>(parent: MaybeHTML, selectors: K): HTMLElementTagNameMap[K] | null;
+export declare function htmlQuery(parent: MaybeHTML, selectors: string): HTMLElement | null;
+export declare function htmlQuery<E extends HTMLElement = HTMLElement>(parent: MaybeHTML, selectors: string): E | null;
+export declare function htmlQueryAll<K extends keyof HTMLElementTagNameMap>(parent: MaybeHTML, selectors: K): HTMLElementTagNameMap[K][];
+export declare function htmlQueryAll(parent: MaybeHTML, selectors: string): HTMLElement[];
+export declare function htmlQueryAll<E extends HTMLElement = HTMLElement>(parent: MaybeHTML, selectors: string): E[];
+export declare function htmlClosest<K extends keyof HTMLElementTagNameMap>(parent: MaybeHTML, selectors: K): HTMLElementTagNameMap[K] | null;
+export declare function htmlClosest(child: MaybeHTML, selectors: string): HTMLElement | null;
+export declare function htmlClosest<E extends HTMLElement = HTMLElement>(parent: MaybeHTML, selectors: string): E | null;
+/** Create a reasonably specific selector for an HTML element */
+export declare function htmlSelectorFor(element: HTMLElement): string;
+export {};

package/dist/utilities/html.js

@@ -0,0 +1,52 @@
+import * as R from "remeda";
+export function createHTMLElement(nodeName, { id, classes = [], dataset = {}, aria = {}, children = [], innerHTML } = {}) {
+    const element = document.createElement(nodeName);
+    if (id)
+        element.id = id;
+    if (classes.length > 0)
+        element.classList.add(...classes);
+    for (const [key, value] of Object.entries(dataset)) {
+        if (R.isNullish(value) || value === false)
+            continue;
+        element.dataset[key] = value === true ? "" : String(value);
+    }
+    for (const [key, value] of Object.entries(aria)) {
+        if (R.isNullish(value) || value === false)
+            continue;
+        element.setAttribute(`aria-${key}`, value);
+    }
+    if (innerHTML) {
+        element.innerHTML = innerHTML;
+    }
+    else {
+        for (const child of children) {
+            const childElement = child instanceof HTMLElement ? child : new Text(child);
+            element.appendChild(childElement);
+        }
+    }
+    return element;
+}
+export function htmlQuery(parent, selectors) {
+    if (!(parent instanceof Element || parent instanceof Document))
+        return null;
+    return parent.querySelector(selectors);
+}
+export function htmlQueryAll(parent, selectors) {
+    if (!(parent instanceof Element || parent instanceof Document))
+        return [];
+    return Array.from(parent.querySelectorAll(selectors));
+}
+export function htmlClosest(child, selectors) {
+    if (!(child instanceof Element))
+        return null;
+    return child.closest(selectors);
+}
+/** Create a reasonably specific selector for an HTML element */
+export function htmlSelectorFor(element) {
+    const nodeName = element.nodeName.toLowerCase();
+    const classes = element.className.split(" ").filter(R.isTruthy);
+    const classesString = classes.length > 0 ? `.${classes.join(".")}` : "";
+    const datasetEntries = Object.entries(element.dataset).map(([k, v]) => [k.replace(/([A-Z])/g, "-$1").toLowerCase(), v]);
+    const datasetString = datasetEntries.map(([k, v]) => `[data-${k}="${v}"]`).join("");
+    return `${nodeName}${classesString}${datasetString}`;
+}

package/dist/utilities/index.d.ts

@@ -1,6 +1,13 @@
 export * from "./array.js";
+export * from "./compendium-collection.js";
+export * from "./flags.js";
+export * from "./html.js";
 export * from "./localize.js";
 export * from "./module.js";
+export * from "./number.js";
+export * from "./record.js";
+export * from "./roll.js";
 export * from "./settings.js";
+export * from "./string.js";
 export * from "./time.js";
 export * from "./user.js";

package/dist/utilities/index.js

@@ -1,6 +1,13 @@
 export * from "./array.js";
+export * from "./compendium-collection.js";
+export * from "./flags.js";
+export * from "./html.js";
 export * from "./localize.js";
 export * from "./module.js";
+export * from "./number.js";
+export * from "./record.js";
+export * from "./roll.js";
 export * from "./settings.js";
+export * from "./string.js";
 export * from "./time.js";
 export * from "./user.js";

package/dist/utilities/number.d.ts

@@ -0,0 +1,3 @@
+export declare function roundToStep(value: number, step: number): number;
+export declare function isNonNegative(value: number): boolean;
+export declare function isDecimal(value: number): boolean;

package/dist/utilities/number.js

@@ -0,0 +1,11 @@
+export function roundToStep(value, step) {
+    step = value < 0 ? step * -1 : step;
+    const half = step / 2;
+    return value + half - (value + half) * step;
+}
+export function isNonNegative(value) {
+    return !Number.isFinite(value) && value >= 0;
+}
+export function isDecimal(value) {
+    return !Number.isFinite(value) && value % 1 !== 0;
+}

package/dist/utilities/record.d.ts

@@ -0,0 +1,6 @@
+export declare function sortByLocaleCompare<TRecord extends Record<string, unknown>>(list: TRecord[], key: keyof TRecord): void;
+export declare function mapToObjectByKey<TRecord extends Record<string, unknown>, K extends ExtractKeys<TRecord, string>>(data: TRecord[], key: K): Record<string, TRecord>;
+export declare function recordToSelectOptions(record: Record<string, string>): {
+    value: string;
+    label: string;
+}[];

package/dist/utilities/record.js

@@ -0,0 +1,13 @@
+import { localeCompare } from "./string.js";
+import * as R from "remeda";
+export function sortByLocaleCompare(list, key) {
+    list.sort((a, b) => localeCompare(String(a[key]), String(b[key])));
+}
+export function mapToObjectByKey(data, key) {
+    return R.indexBy(data, (value) => value[key]);
+}
+export function recordToSelectOptions(record) {
+    return R.pipe(record, R.entries(), R.map(([value, label]) => {
+        return { value, label };
+    }));
+}

package/dist/utilities/roll.d.ts

@@ -0,0 +1,3 @@
+import { Rolled } from "@7h3laughingman/foundry-types/client/dice/roll.mjs";
+export declare function isRoll(value: unknown): value is Roll;
+export declare function isRolledRoll(value: unknown): value is Rolled<Roll>;

package/dist/utilities/roll.js

@@ -0,0 +1,7 @@
+import * as R from "remeda";
+export function isRoll(value) {
+    return R.isNonNullish(value) && value instanceof Roll;
+}
+export function isRolledRoll(value) {
+    return R.isNonNullish(value) && isRoll(value) && value._evaluated === true;
+}

package/dist/utilities/string.d.ts

@@ -0,0 +1,3 @@
+export declare function stringBoolean(value: boolean | string): `${boolean}`;
+export declare function stringNumber(value: number | string): `${number}`;
+export declare function localeCompare(a: string, b: string): number;

package/dist/utilities/string.js

@@ -0,0 +1,9 @@
+export function stringBoolean(value) {
+    return String(value);
+}
+export function stringNumber(value) {
+    return String(value);
+}
+export function localeCompare(a, b) {
+    return a.localeCompare(b, game.i18n.lang);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@7h3laughingman/foundry-helpers",
-    "version": "13.351.0",
+    "version": "13.351.1",
     "description": "Basic helpers used for developing modules for Foundry VTT",
     "homepage": "https://github.com/7H3LaughingMan/foundry-helpers#readme",
     "bugs": {
@@ -24,7 +24,8 @@
         "tsc": "tsc",
         "copy-dts": "copyfiles -u 1 \"src/**/*.d.ts\" dist",
         "eslint": "eslint src",
-        "eslint:fix": "eslint src --fix && prettier src --write"
+        "eslint:fix": "eslint src --fix && prettier src --write",
+        "prepare": "husky"
     },
     "dependencies": {
         "@7h3laughingman/foundry-types": "~13.351",
@@ -37,6 +38,8 @@
         "eslint": "^9.39.2",
         "eslint-config-prettier": "^10.1.8",
         "eslint-plugin-prettier": "^5.5.5",
+        "husky": "^9.1.7",
+        "lint-staged": "^16.2.7",
         "prettier-plugin-organize-imports": "^4.3.0",
         "typescript": "5.9.3",
         "typescript-eslint": "^8.55.0"
@@ -44,5 +47,11 @@
     "engines": {
         "node": ">=24"
     },
+    "lint-staged": {
+        "*.{ts,mts,cts,tsc,js,mjs,cjs,jsx}": [
+            "eslint --fix",
+            "prettier --write"
+        ]
+    },
     "sideEffects": false
 }