@shoru/kitten 0.0.6 → 0.1.1

package/src/plugins/registry.js

@@ -1,95 +1,185 @@
-import { EVENTS } from './config.js';
-
-const plugins = new Map();
-
-const eventCounts = new Map([...EVENTS].map(e => [e, 0]));
-
-const buckets = Object.fromEntries(
-  [...EVENTS].map(e => [e, { auto: new Map(), match: new Map() }])
-);
-
-// Plugin Map Operations
-
-export function getPlugin(id) {
-  return plugins.get(id);
-}
-
-export function setPlugin(id, plugin) {
-  plugins.set(id, plugin);
-}
-
-export function deletePlugin(id) {
-  plugins.delete(id);
-}
-
-export function getAllPlugins() {
-  return plugins;
-}
-
-export function getPluginCount() {
-  return plugins.size;
-}
-
-// Bucket Operations
-
-export function getBucket(event) {
-  return buckets[event];
-}
-
-export function getEventCounts() {
-  return eventCounts;
-}
-
-export function registerToBuckets(id, plugin) {
-  const key = plugin._meta.matchers ? 'match' : 'auto';
-
-  for (const event of plugin._meta.events) {
-    const bucket = buckets[event]?.[key];
-    if (bucket && !bucket.has(id)) {
-      bucket.set(id, plugin);
-      eventCounts.set(event, (eventCounts.get(event) ?? 0) + 1);
-    }
-  }
-}
-
-export function unregisterFromBuckets(id) {
-  const plugin = plugins.get(id);
-  const events = plugin?._meta?.events ?? [];
-
-  for (const event of events) {
-    const bucket = buckets[event];
-    if (bucket?.auto.delete(id) || bucket?.match.delete(id)) {
-      eventCounts.set(event, Math.max(0, (eventCounts.get(event) ?? 1) - 1));
-    }
-  }
-}
-
-export function unloadByFilePath(filePath) {
-  const idsToUnload = [];
-
-  for (const [id, plugin] of plugins) {
-    if (plugin._meta?.filePath === filePath) {
-      idsToUnload.push(id);
-    }
-  }
-
-  for (const id of idsToUnload) {
-    unregisterFromBuckets(id);
-    plugins.delete(id);
-  }
-
-  return idsToUnload.length;
-}
-
-export function clear() {
-  plugins.clear();
-
-  for (const bucket of Object.values(buckets)) {
-    bucket.auto.clear();
-    bucket.match.clear();
-  }
-
-  for (const event of EVENTS) {
-    eventCounts.set(event, 0);
-  }
+import path from 'path';
+import { EVENTS } from './config.js';
+
+const plugins = new Map();
+
+const eventCounts = new Map([...EVENTS].map(e => [e, 0]));
+
+const createBucket = () => {
+  const allMatch = new Map();
+  return {
+    auto: new Map(),
+    commandMap: new Map(),
+    prefixlessMap: new Map(),
+    regexList: new Map(),
+    allMatch,
+    get match() {
+      return allMatch;
+    },
+  };
+};
+
+const buckets = Object.fromEntries(
+  [...EVENTS].map(e => [e, createBucket()])
+);
+
+// Plugin Map Operations
+
+export function getPlugin(id) {
+  return plugins.get(id);
+}
+
+export function setPlugin(id, plugin) {
+  plugins.set(id, plugin);
+}
+
+export function deletePlugin(id) {
+  plugins.delete(id);
+}
+
+export function getAllPlugins() {
+  return plugins;
+}
+
+export function getPluginCount() {
+  return plugins.size;
+}
+
+// Bucket Operations
+
+export function getBucket(event) {
+  return buckets[event];
+}
+
+export function getEventCounts() {
+  return eventCounts;
+}
+
+export function registerToBuckets(id, plugin) {
+  const matchers = plugin._meta?.matchers;
+  const isMatch = Boolean(matchers);
+
+  for (const event of plugin._meta.events) {
+    const bucket = buckets[event];
+    if (!bucket) continue;
+
+    if (!isMatch) {
+      if (!bucket.auto.has(id)) {
+        eventCounts.set(event, (eventCounts.get(event) ?? 0) + 1);
+      }
+      bucket.auto.set(id, plugin);
+    } else {
+      if (!bucket.allMatch.has(id)) {
+        eventCounts.set(event, (eventCounts.get(event) ?? 0) + 1);
+      }
+      bucket.allMatch.set(id, plugin);
+
+      // Index exact string commands with case normalization
+      if (matchers.strings && matchers.strings.length > 0) {
+        for (const rawCmd of matchers.strings) {
+          const normCmd = rawCmd.toLowerCase();
+
+          if (matchers.prefixes && matchers.prefixes.size > 0) {
+            for (const rawPrefix of matchers.prefixes) {
+              const normPrefix = rawPrefix.toLowerCase();
+              const key = `${normPrefix}${normCmd}`;
+              let list = bucket.commandMap.get(key);
+              if (!list) {
+                list = [];
+                bucket.commandMap.set(key, list);
+              }
+              list.push({ id, plugin, match: normCmd, prefix: normPrefix });
+            }
+          } else {
+            let list = bucket.prefixlessMap.get(normCmd);
+            if (!list) {
+              list = [];
+              bucket.prefixlessMap.set(normCmd, list);
+            }
+            list.push({ id, plugin, match: normCmd, prefix: null });
+          }
+        }
+      }
+
+      // Index regex matchers
+      if (matchers.regexes && matchers.regexes.length > 0) {
+        bucket.regexList.set(id, { plugin, regexes: matchers.regexes });
+      }
+    }
+  }
+}
+
+export function unregisterFromBuckets(id) {
+  const plugin = plugins.get(id);
+  const events = plugin?._meta?.events ?? [];
+
+  for (const event of events) {
+    const bucket = buckets[event];
+    if (!bucket) continue;
+
+    let removed = false;
+    if (bucket.auto.delete(id)) removed = true;
+    if (bucket.allMatch.delete(id)) removed = true;
+
+    // Clean up commandMap
+    for (const [key, list] of bucket.commandMap) {
+      const filtered = list.filter(item => item.id !== id);
+      if (filtered.length === 0) {
+        bucket.commandMap.delete(key);
+      } else {
+        bucket.commandMap.set(key, filtered);
+      }
+    }
+
+    // Clean up prefixlessMap
+    for (const [key, list] of bucket.prefixlessMap) {
+      const filtered = list.filter(item => item.id !== id);
+      if (filtered.length === 0) {
+        bucket.prefixlessMap.delete(key);
+      } else {
+        bucket.prefixlessMap.set(key, filtered);
+      }
+    }
+
+    // Clean up regexList
+    bucket.regexList.delete(id);
+
+    if (removed) {
+      eventCounts.set(event, Math.max(0, (eventCounts.get(event) ?? 1) - 1));
+    }
+  }
+}
+
+export function unloadByFilePath(filePath) {
+  const normalizedTarget = path.resolve(filePath);
+  const idsToUnload = [];
+
+  for (const [id, plugin] of plugins) {
+    if (plugin._meta?.filePath && path.resolve(plugin._meta.filePath) === normalizedTarget) {
+      idsToUnload.push(id);
+    }
+  }
+
+  for (const id of idsToUnload) {
+    unregisterFromBuckets(id);
+    plugins.delete(id);
+  }
+
+  return idsToUnload.length;
+}
+
+export function clear() {
+  plugins.clear();
+
+  for (const bucket of Object.values(buckets)) {
+    bucket.auto.clear();
+    bucket.allMatch.clear();
+    bucket.commandMap.clear();
+    bucket.prefixlessMap.clear();
+    bucket.regexList.clear();
+  }
+
+  for (const event of EVENTS) {
+    eventCounts.set(event, 0);
+  }
 }

package/src/plugins/watcher.js

@@ -50,32 +50,34 @@ export function clearTimers() {
 }
 
 function scheduleHMR(filePath, type) {
-  clearTimeout(debounceTimers.get(filePath));
+  const resolved = path.resolve(filePath);
+  clearTimeout(debounceTimers.get(resolved));
 
   debounceTimers.set(
-    filePath,
+    resolved,
     setTimeout(() => {
-      debounceTimers.delete(filePath);
-      executeHMR(filePath, type);
+      debounceTimers.delete(resolved);
+      executeHMR(resolved, type);
     }, debounceMs)
   );
 }
 
 async function executeHMR(filePath, type) {
-  const rel = path.relative(PLUGIN_DIR, filePath);
+  const resolved = path.resolve(filePath);
+  const rel = path.relative(PLUGIN_DIR, resolved);
 
   try {
-    await getLock(filePath).runExclusive(async () => {
+    await getLock(resolved).runExclusive(async () => {
       if (type === 'unlink') {
-        const count = unloadByFilePath(filePath);
+        const count = unloadByFilePath(resolved);
         logger.info(`[HMR] Unloaded: ${rel} (${count})`);
       } else {
         // Load new plugins without registering
-        const parent = getParentFolder(path.dirname(filePath));
-        const loaded = await loadFile(filePath, parent, false);
+        const parent = getParentFolder(path.dirname(resolved));
+        const loaded = await loadFile(resolved, parent, false);
 
         // Remove old plugins for this file
-        unloadByFilePath(filePath);
+        unloadByFilePath(resolved);
 
         // Register newly loaded plugins
         for (const [id, plugin] of loaded) {
@@ -93,7 +95,7 @@ async function executeHMR(filePath, type) {
     handleError(`[HMR:${rel}] Failed:`, err);
   } finally {
     if (type === 'unlink') {
-      deleteLockIfUnused(filePath);
+      deleteLockIfUnused(resolved);
     }
   }
 }

package/src/utils/time-string.js

@@ -1,19 +1,31 @@
-import { getConfig } from '#internals.js';
-
-const { timeZone } = await getConfig();
-
-export const getTimeString = (timestamp, TIME_ZONE = timeZone) => {
-  const date = new Date(timestamp * 1000);
-  const options = { 
-    year: 'numeric',
-    month: 'long',
-    day: 'numeric',
-    hour: '2-digit',
-    minute: '2-digit',
-    second: '2-digit',
-    hour12: false,
-    TIME_ZONE
-  };
-  const result = date.toLocaleDateString('en-US', options)
-  return result.split(' at ')
-}
+import { getConfig } from '#internals.js';
+
+const { timeZone: defaultTimeZone } = await getConfig();
+
+const formatters = new Map();
+
+function getFormatter(tz) {
+  let formatter = formatters.get(tz);
+  if (!formatter) {
+    formatter = new Intl.DateTimeFormat('en-US', {
+      year: 'numeric',
+      month: 'long',
+      day: 'numeric',
+      hour: '2-digit',
+      minute: '2-digit',
+      second: '2-digit',
+      hour12: false,
+      timeZone: tz,
+    });
+    formatters.set(tz, formatter);
+  }
+  return formatter;
+}
+
+export const getTimeString = (timestamp, timeZone = defaultTimeZone) => {
+  if (!timestamp) return ['', ''];
+  const date = new Date(timestamp * 1000);
+  const formatter = getFormatter(timeZone);
+  const result = formatter.format(date);
+  return result.split(' at ');
+};

package/src/utils/type-conversions.js

@@ -1,5 +1,11 @@
-export const isString = x => typeof x === "string";
- 
-export const toNumber = x => (x && typeof x.toNumber === "function") ? x.toNumber() : x;
- 
-export const toBase64 = x => x ? Buffer.from(x).toString("base64") : x;
+export const isString = (x) => typeof x === 'string';
+
+export const toNumber = (x) => (x && typeof x.toNumber === 'function' ? x.toNumber() : x);
+
+export const toBase64 = (x) => {
+  if (!x) return x;
+  if (typeof x === 'string') return x;
+  if (Buffer.isBuffer(x)) return x.toString('base64');
+  if (x instanceof Uint8Array) return Buffer.from(x.buffer, x.byteOffset, x.byteLength).toString('base64');
+  return Buffer.from(x).toString('base64');
+};