libSmartAttributes | 0.0.2 | Improve Behavior

libSmartAttributes/0.0.2/libSmartAttributes.js

@@ -0,0 +1,97 @@
+// libSmartAttributes v0.0.2 by GUD Team | libSmartAttributes provides an interface for managing beacon attributes in a slightly smarter way.
+var libSmartAttributes = (function () {
+    'use strict';
+
+    async function getAttribute(characterId, name, type = "current") {
+        // Try for legacy attribute first
+        const legacyAttr = findObjs({
+            _type: "attribute",
+            _characterid: characterId,
+            name: name,
+        })[0];
+        if (legacyAttr) {
+            return legacyAttr.get(type);
+        }
+        // Then try for the beacon computed
+        const beaconName = type === "current" ? name : `${name}_max`;
+        const beaconAttr = await getSheetItem(characterId, beaconName);
+        if (beaconAttr !== null && beaconAttr !== undefined) {
+            return beaconAttr;
+        }
+        // Then try for the user attribute
+        const userAttr = await getSheetItem(characterId, `user.${beaconName}`);
+        if (userAttr !== null && userAttr !== undefined) {
+            return userAttr;
+        }
+        log(`Attribute ${beaconName} not found on character ${characterId}`);
+        return undefined;
+    }
+    async function setAttribute(characterId, name, value, type = "current", options) {
+        // Try for legacy attribute first
+        const legacyAttr = findObjs({
+            _type: "attribute",
+            _characterid: characterId,
+            name: name,
+        })[0];
+        if (legacyAttr && options?.setWithWorker) {
+            legacyAttr.setWithWorker({ [type]: value });
+            return;
+        }
+        else if (legacyAttr) {
+            legacyAttr.set({ [type]: value });
+            return;
+        }
+        // Then try for the beacon computed
+        const beaconName = type === "current" ? name : `${name}_max`;
+        const beaconAttr = await getSheetItem(characterId, beaconName);
+        if (beaconAttr !== null && beaconAttr !== undefined) {
+            setSheetItem(characterId, beaconName, value);
+            return;
+        }
+        // Guard against creating user attributes if noCreate is set
+        if (options?.noCreate) {
+            log(`Attribute ${beaconName} not found on character ${characterId}, and noCreate option is set. Skipping creation.`);
+            return;
+        }
+        // Then default to a user attribute
+        setSheetItem(characterId, `user.${beaconName}`, value);
+        return;
+    }
+    async function deleteAttribute(characterId, name, type = "current") {
+        // Try for legacy attribute first
+        const legacyAttr = findObjs({
+            _type: "attribute",
+            _characterid: characterId,
+            name: name,
+        })[0];
+        if (legacyAttr) {
+            legacyAttr.remove();
+            return;
+        }
+        // Then try for the beacon computed
+        const beaconName = type === "current" ? name : `${name}_max`;
+        const beaconAttr = await getSheetItem(characterId, beaconName);
+        if (beaconAttr !== null && beaconAttr !== undefined) {
+            log(`Cannot delete beacon computed attribute ${name} on character ${characterId}. Setting to undefined instead`);
+            setSheetItem(characterId, name, undefined);
+            return;
+        }
+        // Then try for the user attribute
+        const userAttr = await getSheetItem(characterId, `user.${beaconName}`);
+        if (userAttr !== null && userAttr !== undefined) {
+            log(`Deleting user attribute ${name} on character ${characterId}`);
+            setSheetItem(characterId, `user.${beaconName}`, undefined);
+            return;
+        }
+        log(`Attribute ${beaconName} not found on character ${characterId}, nothing to delete`);
+        return;
+    }
+    var index = {
+        getAttribute,
+        setAttribute,
+        deleteAttribute,
+    };
+
+    return index;
+
+})();

libSmartAttributes/package.json

@@ -2,8 +2,10 @@
   "name": "lib-smart-attributes",
   "version": "1.0.0",
   "type": "module",
-  "main": "src/index.ts",
-  "types": "0.0.1/index.d.ts",
+  "exports": {
+    ".": "./src/index.ts",
+    "./types": "./src/types.d.ts"
+  },
   "scripts": {
     "lint": "eslint",
     "lint:fix": "eslint --fix",

libSmartAttributes/rollup.config.ts

@@ -9,17 +9,14 @@ export default defineConfig({
 
   output: {
     file: `${json.version}/${json.name}.js`,
-    format: "iife",
     name: json.name,
+    format: "iife",
     sourcemap: false,
     banner: `// ${json.name} v${json.version} by ${json.authors} | ${json.description}`,
   },
 
   plugins: [
     del({ targets: `${json.version}/*`, runOnce: true }),
-    typescript({
-      declaration: true,
-      declarationDir: `${json.version}`,
-    }),
+    typescript({}),
   ]
 });

libSmartAttributes/script.json

@@ -1,6 +1,6 @@
 {
   "name": "libSmartAttributes",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "description": "libSmartAttributes provides an interface for managing beacon attributes in a slightly smarter way.",
   "authors": "GUD Team",
   "roll20userid": "8705027",
@@ -9,5 +9,7 @@
   "conflicts": [],
   "script": "libSmartAttributes.js",
   "useroptions": [],
-  "previousversions": []
+  "previousversions": [
+    "0.0.1"
+  ]
 }

libSmartAttributes/src/index.ts

@@ -13,23 +13,25 @@ async function getAttribute(characterId: string, name: string, type: AttributeTy
   }
 
   // Then try for the beacon computed
-  const beaconAttr = await getSheetItem(characterId, name);
+  const beaconName = type === "current" ? name : `${name}_max`;
+  const beaconAttr = await getSheetItem(characterId, beaconName);
   if (beaconAttr !== null && beaconAttr !== undefined) {
     return beaconAttr;
   }
 
   // Then try for the user attribute
-  const userAttr = await getSheetItem(characterId, `user.${name}`);
+  const userAttr = await getSheetItem(characterId, `user.${beaconName}`);
   if (userAttr !== null && userAttr !== undefined) {
     return userAttr;
   }
 
-  log(`Attribute ${name} not found on character ${characterId}`);
+  log(`Attribute ${beaconName} not found on character ${characterId}`);
   return undefined;
 };
 
 type SetOptions = {
   setWithWorker?: boolean;
+  noCreate?: boolean;
 };
 
 async function setAttribute(characterId: string, name: string, value: unknown, type: AttributeType = "current", options?: SetOptions) {
@@ -41,24 +43,35 @@ async function setAttribute(characterId: string, name: string, value: unknown, t
   })[0];
 
   if (legacyAttr && options?.setWithWorker) {
-    return legacyAttr.setWithWorker({ [type]: value });
+    legacyAttr.setWithWorker({ [type]: value });
+    return;
   }
 
   else if (legacyAttr) {
-    return legacyAttr.set({ [type]: value });
+    legacyAttr.set({ [type]: value });
+    return;
   }
 
   // Then try for the beacon computed
-  const beaconAttr = await getSheetItem(characterId, name);
+  const beaconName = type === "current" ? name : `${name}_max`;
+  const beaconAttr = await getSheetItem(characterId, beaconName);
   if (beaconAttr !== null && beaconAttr !== undefined) {
-    return setSheetItem(characterId, name, value);
+    setSheetItem(characterId, beaconName, value);
+    return;
+  }
+
+  // Guard against creating user attributes if noCreate is set
+  if (options?.noCreate) {
+    log(`Attribute ${beaconName} not found on character ${characterId}, and noCreate option is set. Skipping creation.`);
+    return;
   }
 
   // Then default to a user attribute
-  return setSheetItem(characterId, `user.${name}`, value);
+  setSheetItem(characterId, `user.${beaconName}`, value);
+  return;
 };
 
-async function deleteAttribute(characterId: string, name: string) {
+async function deleteAttribute(characterId: string, name: string, type: AttributeType = "current") {
   // Try for legacy attribute first
   const legacyAttr = findObjs({
     _type: "attribute",
@@ -67,15 +80,29 @@ async function deleteAttribute(characterId: string, name: string) {
   })[0];
 
   if (legacyAttr) {
-    return legacyAttr.remove();
+    legacyAttr.remove();
+    return;
   }
 
   // Then try for the beacon computed
-  const beaconAttr = await getSheetItem(characterId, name);
+  const beaconName = type === "current" ? name : `${name}_max`;
+  const beaconAttr = await getSheetItem(characterId, beaconName);
   if (beaconAttr !== null && beaconAttr !== undefined) {
     log(`Cannot delete beacon computed attribute ${name} on character ${characterId}. Setting to undefined instead`);
-    return setSheetItem(characterId, name, undefined);
+    setSheetItem(characterId, name, undefined);
+    return;
   }
+
+  // Then try for the user attribute
+  const userAttr = await getSheetItem(characterId, `user.${beaconName}`);
+  if (userAttr !== null && userAttr !== undefined) {
+    log(`Deleting user attribute ${name} on character ${characterId}`);
+    setSheetItem(characterId, `user.${beaconName}`, undefined);
+    return;
+  }
+
+  log(`Attribute ${beaconName} not found on character ${characterId}, nothing to delete`);
+  return;
 };
 
 export default {

libSmartAttributes/src/types.d.ts

@@ -0,0 +1,5 @@
+declare namespace SmartAttributes {
+  function getAttribute(characterId: string, name: string, type?: "current" | "max"): Promise<string | number | undefined>;
+  function setAttribute(characterId: string, name: string, value: unknown, type?: "current" | "max", options?: { setWithWorker?: boolean, noCreate?: boolean }): Promise<void>;
+  function deleteAttribute(characterId: string, name: string, type?: "current" | "max", options?: { setWithWorker?: boolean }): Promise<void>;
+}