Allow API to work on item UUIDs

DFreds · DFreds · commit c3e4bb8b11cc · 2025-03-19T16:44:30.000-04:00
diff --git a/src/ts/effect-interface.ts b/src/ts/effect-interface.ts
@@ -1,11 +1,11 @@
 import { ActiveEffectSource } from "types/foundry/common/documents/active-effect.js";
 import { Settings } from "./settings.ts";
 import {
-    findActorByUuid,
-    findActorByUuidSync,
+    findDocumentByUuidSync,
     findAllEffects,
     findFolder,
     findFolders,
+    findDocumentByUuid,
 } from "./utils/finds.ts";
 import { getActorUuids } from "./utils/gets.ts";
 import { error, log } from "./logger.ts";
@@ -254,10 +254,10 @@ class EffectInterface {
         effectName,
         uuid,
     }: IHasEffectApplied): boolean {
-        const actor = findActorByUuidSync(uuid);
+        const document = findDocumentByUuidSync(uuid);
 
         return (
-            actor?.effects?.some((effect) => {
+            document?.effects?.some((effect) => {
                 const isConvenient = Flags.isConvenient(effect);
                 const isEnabled = !effect.disabled;
                 const isMatchingId = effect.id === effectId;
@@ -372,9 +372,9 @@ class EffectInterface {
             return [];
         }
 
-        const actor = await findActorByUuid(uuid);
-        if (!actor) {
-            error(`Actor ${uuid} could not be found`);
+        const document = await findDocumentByUuid(uuid);
+        if (!document) {
+            error(`Document ${uuid} could not be found`);
             return [];
         }
 
@@ -418,9 +418,9 @@ class EffectInterface {
             return;
         }
 
-        const actor = await findActorByUuid(uuid);
-        if (!actor) {
-            error(`Actor ${uuid} could not be found`);
+        const document = await findDocumentByUuid(uuid);
+        if (!document) {
+            error(`Document ${uuid} could not be found`);
             return;
         }
 
diff --git a/src/ts/sockets/sockets.ts b/src/ts/sockets/sockets.ts
@@ -1,5 +1,5 @@
 import { ActiveEffectSource } from "types/foundry/common/documents/active-effect.js";
-import { findActorByUuid } from "../utils/finds.ts";
+import { findDocumentByUuid } from "../utils/finds.ts";
 import { log } from "../logger.ts";
 import { Mapping } from "../effects/mapping.ts";
 import { Flags } from "../utils/flags.ts";
@@ -60,23 +60,25 @@ class Sockets {
         effectData,
         uuid,
     }: AddEffectMessageData): Promise<Document[]> {
-        const actor = await findActorByUuid(uuid);
+        const document = await findDocumentByUuid(uuid);
         const activeEffectsToApply = [effectData];
 
-        if (!actor) return []; // This should already be checked for before the socket
+        if (!document) return []; // This should already be checked for before the socket
 
         const isDynamic = Flags.isDynamic(effectData);
         if (isDynamic) {
             const mapping = new Mapping();
             const systemDefinition = mapping.findSystemDefinitionForSystemId();
 
-            await systemDefinition?.dynamicEffectsHandler?.handleDynamicEffects(
-                effectData,
-                actor,
-            );
+            if (document instanceof Actor) {
+                await systemDefinition?.dynamicEffectsHandler?.handleDynamicEffects(
+                    effectData,
+                    document,
+                );
+            }
         }
 
-        const createdEffects = await actor.createEmbeddedDocuments(
+        const createdEffects = await document.createEmbeddedDocuments(
             "ActiveEffect",
             activeEffectsToApply,
         );
@@ -104,7 +106,9 @@ class Sockets {
             }
         }
 
-        log(`Added effect ${effectData.name} to ${actor.name} - ${actor.id}`);
+        log(
+            `Added effect ${effectData.name} to ${document.name} - ${document.id}`,
+        );
 
         return createdEffects;
     }
@@ -122,30 +126,34 @@ class Sockets {
         uuid,
         origin,
     }: RemoveEffectMessageData): Promise<void> {
-        const actor = await findActorByUuid(uuid);
-
-        if (!actor) return; // This should already be checked for before the socket
-
-        const effectToRemove = actor.effects.find((activeEffect) => {
-            const isConvenient = Flags.isConvenient(activeEffect);
-            const isMatchingId = activeEffect.id === effectId;
-            const isMatchingName = activeEffect.name === effectName;
-            const isMatchingCeId =
-                Flags.getCeEffectId(activeEffect) === effectId;
-
-            const matches =
-                isConvenient &&
-                (isMatchingId || isMatchingName || isMatchingCeId);
-
-            return origin ? matches && activeEffect.origin === origin : matches;
-        });
+        const document = await findDocumentByUuid(uuid);
+
+        if (!document) return; // This should already be checked for before the socket
+
+        const effectToRemove = (document.effects as any).find(
+            (activeEffect: ActiveEffect<any>) => {
+                const isConvenient = Flags.isConvenient(activeEffect);
+                const isMatchingId = activeEffect.id === effectId;
+                const isMatchingName = activeEffect.name === effectName;
+                const isMatchingCeId =
+                    Flags.getCeEffectId(activeEffect) === effectId;
+
+                const matches =
+                    isConvenient &&
+                    (isMatchingId || isMatchingName || isMatchingCeId);
+
+                return origin
+                    ? matches && activeEffect.origin === origin
+                    : matches;
+            },
+        );
 
         if (!effectToRemove) return;
 
         await effectToRemove.delete();
 
         log(
-            `Removed effect ${effectToRemove.name} from ${actor.name} - ${actor.id}`,
+            `Removed effect ${effectToRemove.name} from ${document.name} - ${document.id}`,
         );
     }
 }
diff --git a/src/ts/utils/finds.ts b/src/ts/utils/finds.ts
@@ -11,33 +11,45 @@ function findModuleById(moduleId: string): Module | undefined {
  * @param uuid The actor UUID
  * @returns the actor that was found via the UUID or undefined if not found
  */
-async function findActorByUuid(
+async function findDocumentByUuid(
     uuid: string,
-): Promise<Actor<TokenDocument<any> | null> | undefined> {
-    const actorToken = await fromUuid(uuid);
+): Promise<Actor<any> | Item<any> | undefined> {
+    const document = await fromUuid(uuid);
+
+    if (!document) return undefined;
 
-    if (!actorToken) return undefined;
+    if (document instanceof TokenDocument) {
+        return document.actor ?? undefined;
+    }
+
+    if (document instanceof Actor) {
+        return document;
+    }
 
-    if (actorToken instanceof TokenDocument) {
-        return actorToken.actor ?? undefined;
-    } else if (actorToken instanceof Actor) {
-        return actorToken;
+    if (document instanceof Item) {
+        return document;
     }
 
     return undefined;
 }
 
-function findActorByUuidSync(
+function findDocumentByUuidSync(
     uuid: string,
-): Actor<TokenDocument<any> | null> | undefined {
-    const actorToken = fromUuidSync(uuid);
+): Actor<any> | Item<any> | undefined {
+    const document = fromUuidSync(uuid);
 
-    if (!actorToken) return undefined;
+    if (!document) return undefined;
+
+    if (document instanceof TokenDocument) {
+        return document.actor ?? undefined;
+    }
+
+    if (document instanceof Actor) {
+        return document;
+    }
 
-    if (actorToken instanceof TokenDocument) {
-        return actorToken.actor ?? undefined;
-    } else if (actorToken instanceof Actor) {
-        return actorToken;
+    if (document instanceof Item) {
+        return document;
     }
 
     return undefined;
@@ -178,8 +190,8 @@ function findEffectByCeId(ceId: string): ActiveEffect<any> | undefined {
 
 export {
     findModuleById,
-    findActorByUuid,
-    findActorByUuidSync,
+    findDocumentByUuid,
+    findDocumentByUuidSync,
     findFolder,
     findFolders,
     findAllEffects,
diff --git a/src/ts/utils/flags.ts b/src/ts/utils/flags.ts
@@ -1,4 +1,6 @@
-import { ActiveEffectSource } from "types/foundry/common/documents/active-effect.js";
+import BaseActiveEffect, {
+    ActiveEffectSource,
+} from "types/foundry/common/documents/active-effect.js";
 import { ItemSource } from "types/foundry/common/documents/item.js";
 import { MODULE_ID } from "../constants.ts";
 
@@ -17,7 +19,10 @@ class Flags {
     };
 
     static getCeEffectId(
-        effect: ActiveEffect<any> | PreCreate<ActiveEffectSource>,
+        effect:
+            | ActiveEffect<any>
+            | BaseActiveEffect<any>
+            | PreCreate<ActiveEffectSource>,
     ): string | undefined {
         if (effect instanceof ActiveEffect) {
             return effect.getFlag(MODULE_ID, this.#KEYS.CE_EFFECT_ID) as
