support unique ref and fix not found hint

src/index.ts

@@ -89,31 +89,69 @@ export default class MyPlugin
     return _.sumBy(patterns, (pattern) => this.parseDicePattern(pattern));
   }
 
-  parseEntry(entry: string, depth = 1) {
-    return entry
-      .replace(/\[[d\d\+]+\]/g, (dicePattern) =>
+  parseEntry(name: string, entry: string, depth = 1): string {
+    let result = entry.replace(/\[[d\d\+]+\]/g, (dicePattern) =>
       this.parseDice(dicePattern.slice(1, -1)).toString(),
-      )
+    );
+    if (depth > this.config.maxDepth) {
+      this.logger.warn(
+        `Max depth ${this.config.maxDepth} reached in deck ${name}.`,
+      );
+      return entry;
+    }
+    const usedUniqueIndex = new Map<string, Set<number>>();
+    result = result
       .replace(
-        /\{[^\}]+\}/g,
+        /\{[^%\}]+\}/g,
         (refPattern) =>
-          this.drawFromDeck(refPattern.slice(1, -1), depth + 1) || refPattern,
+          this.drawFromDeck(refPattern.slice(1, -1), depth + 1, name) ||
+          refPattern,
+      )
+      .replace(/\{%[^%\}]+\}/g, (uniqRefPattern) => {
+        const refName = uniqRefPattern.slice(2, -1);
+        let indexArray = usedUniqueIndex.get(refName);
+        if (!indexArray) {
+          indexArray = new Set();
+          usedUniqueIndex.set(refName, indexArray);
+        }
+        const deck = this.decks[refName];
+        if (!deck) {
+          this.logger.warn(
+            `Referenced deck ${refName} not found in deck ${name}.`,
           );
+          return uniqRefPattern;
         }
 
-  drawFromDeck(name: string, depth = 1) {
-    if (depth > this.config.maxDepth) {
+        const availableIndexes = _.range(deck.length).filter(
+          (index) => !indexArray.has(index),
+        );
+        if (availableIndexes.length === 0) {
           this.logger.warn(
-        `Max depth ${this.config.maxDepth} reached in deck ${name}.`,
+            `No more unique entries left for ${refName} in deck ${name}.`,
           );
-      return null;
+          return uniqRefPattern;
         }
+        const index = Random.pick(availableIndexes);
+        indexArray.add(index);
+
+        const entry = deck[index];
+        return this.parseEntry(refName, entry, depth + 1);
+      });
+    return result;
+  }
+
+  drawFromDeck(name: string, depth = 1, referencedDeck?: string): string {
     const deck = this.decks[name];
     if (!deck) {
+      this.logger.warn(
+        `${referencedDeck ? 'Referenced deck' : 'Deck'} ${name} not found${
+          referencedDeck ? `in deck ${referencedDeck}` : ''
+        }.`,
+      );
       return null;
     }
     const entry = Random.pick(deck);
-    return this.parseEntry(entry, depth);
+    return this.parseEntry(name, entry, depth);
   }
 
   async onConnect() {
@@ -195,7 +233,7 @@ export default class MyPlugin
       (d) => d.includes(word),
     );
     if (!allDecks.length) {
-      return notFoundRenderer(word);
+      return notFoundRenderer({ word });
     }
     _.sortBy(allDecks, (deck) => leven(deck, word));
     return `${renderer()}\n${allDecks.join('|')}`;