@buoy-gg/floating-tools-core 3.0.1 → 3.0.2

package/lib/module/dialUsage.js

@@ -1 +1,122 @@
-"use strict";export const USAGE_HALF_LIFE_MS=2592e5;export const USAGE_MIN_SCORE=.01;export function decayScore(e,o){if(!e||e.score<=0)return 0;const r=o-e.lastUsed;return r<=0?e.score:e.score*Math.pow(.5,r/2592e5)}export function recordUsage(e,o,r){const c=decayScore(e[o],r);return{...e,[o]:{score:c+1,lastUsed:r}}}export function rankToolIds(e,o,r){const c=e.map((e,c)=>({id:e,index:c,score:decayScore(o[e],r)}));return c.sort((e,o)=>o.score!==e.score?o.score-e.score:e.index-o.index),c.map(e=>e.id)}export function pruneUsage(e,o){const r={};for(const[c,t]of Object.entries(e))decayScore(t,o)>.01&&(r[c]=t);return r}
+"use strict";
+
+/**
+ * Dial Usage - Recency-weighted usage tracking for the dial menu.
+ *
+ * Pure scoring/ranking logic. No React or platform-specific code.
+ *
+ * The dial menu ranks tools by how recently and frequently they are used.
+ * Each press adds 1 point to a tool's score; that score decays exponentially
+ * over time (half-life ~3 days) so the ordering reflects "what I'm using most
+ * lately" rather than all-time totals.
+ */
+
+// =============================
+// Constants
+// =============================
+
+/**
+ * Half-life of a usage score, in milliseconds (~3 days).
+ * After this much time, an untouched tool's score halves.
+ */
+export const USAGE_HALF_LIFE_MS = 3 * 24 * 60 * 60 * 1000;
+
+/**
+ * Scores at or below this value are treated as zero. Entries that decay
+ * below it can be safely pruned from storage.
+ */
+export const USAGE_MIN_SCORE = 0.01;
+
+// =============================
+// Types
+// =============================
+
+/**
+ * A single tool's usage record.
+ */
+
+/** Map of tool id to its usage record. */
+
+// =============================
+// Scoring
+// =============================
+
+/**
+ * Decay a stored score forward to `now`.
+ *
+ * @param entry - The usage entry to evaluate
+ * @param now - Current epoch ms
+ * @returns The score decayed to `now` (never negative)
+ */
+export function decayScore(entry, now) {
+  if (!entry || entry.score <= 0) return 0;
+  const elapsed = now - entry.lastUsed;
+  // Guard against clock skew producing a score boost.
+  if (elapsed <= 0) return entry.score;
+  return entry.score * Math.pow(0.5, elapsed / USAGE_HALF_LIFE_MS);
+}
+
+/**
+ * Record a single press of a tool, returning a new usage map.
+ *
+ * The existing score is decayed forward to `now` before adding 1, so a
+ * burst of presses accumulates while stale scores naturally fade.
+ *
+ * @param map - Current usage map
+ * @param id - Tool id that was pressed
+ * @param now - Current epoch ms
+ * @returns A new usage map (input is not mutated)
+ */
+export function recordUsage(map, id, now) {
+  const decayed = decayScore(map[id], now);
+  return {
+    ...map,
+    [id]: {
+      score: decayed + 1,
+      lastUsed: now
+    }
+  };
+}
+
+/**
+ * Rank tool ids by decayed usage score, highest first.
+ *
+ * The sort is stable: tools with equal scores (including never-used tools,
+ * which score 0) keep their original order in `orderedIds`. This preserves
+ * registration order as the tie-breaker.
+ *
+ * @param orderedIds - Tool ids in their default/registration order
+ * @param map - Current usage map
+ * @param now - Current epoch ms
+ * @returns A new array of ids sorted by usage
+ */
+export function rankToolIds(orderedIds, map, now) {
+  const scored = orderedIds.map((id, index) => ({
+    id,
+    index,
+    score: decayScore(map[id], now)
+  }));
+  scored.sort((a, b) => {
+    if (b.score !== a.score) return b.score - a.score;
+    return a.index - b.index;
+  });
+  return scored.map(entry => entry.id);
+}
+
+/**
+ * Drop entries whose decayed score has fallen below `USAGE_MIN_SCORE`,
+ * keeping the persisted map from growing unbounded.
+ *
+ * @param map - Current usage map
+ * @param now - Current epoch ms
+ * @returns A new, pruned usage map
+ */
+export function pruneUsage(map, now) {
+  const pruned = {};
+  for (const [id, entry] of Object.entries(map)) {
+    if (decayScore(entry, now) > USAGE_MIN_SCORE) {
+      pruned[id] = entry;
+    }
+  }
+  return pruned;
+}

package/lib/module/easing.js

@@ -1 +1,62 @@
-"use strict";export const easing={linear:e=>e,easeOutCubic:e=>1-Math.pow(1-e,3),easeInCubic:e=>e*e*e,easeInOutCubic:e=>e<.5?4*e*e*e:1-Math.pow(-2*e+2,3)/2,easeOutQuad:e=>1-(1-e)*(1-e),easeOutExpo:e=>1===e?1:1-Math.pow(2,-10*e)};export function getEasing(e){return easing[e]}export function interpolate(e,t,a,n=easing.easeOutCubic){return e+(t-e)*n(Math.max(0,Math.min(1,a)))}export function interpolatePosition(e,t,a,n=easing.easeOutCubic){return{x:interpolate(e.x,t.x,a,n),y:interpolate(e.y,t.y,a,n)}}
+"use strict";
+
+/**
+ * Animation easing functions.
+ * Platform-agnostic - used by both web (RAF) and mobile (Animated).
+ */
+
+/**
+ * Easing functions for animations.
+ * All functions take progress (0-1) and return eased value (0-1).
+ */
+export const easing = {
+  /**
+   * Linear - no easing.
+   */
+  linear: t => t,
+  /**
+   * Ease out cubic - decelerates towards end.
+   * Used for hide/show animations.
+   */
+  easeOutCubic: t => 1 - Math.pow(1 - t, 3),
+  /**
+   * Ease in cubic - accelerates from start.
+   */
+  easeInCubic: t => t * t * t,
+  /**
+   * Ease in-out cubic - smooth acceleration and deceleration.
+   */
+  easeInOutCubic: t => t < 0.5 ? 4 * t * t * t : 1 - Math.pow(-2 * t + 2, 3) / 2,
+  /**
+   * Ease out quad - lighter deceleration than cubic.
+   */
+  easeOutQuad: t => 1 - (1 - t) * (1 - t),
+  /**
+   * Ease out expo - strong deceleration (snappy feel).
+   */
+  easeOutExpo: t => t === 1 ? 1 : 1 - Math.pow(2, -10 * t)
+};
+/**
+ * Get an easing function by name.
+ */
+export function getEasing(name) {
+  return easing[name];
+}
+
+/**
+ * Interpolate between two values using an easing function.
+ */
+export function interpolate(from, to, progress, easingFn = easing.easeOutCubic) {
+  const eased = easingFn(Math.max(0, Math.min(1, progress)));
+  return from + (to - from) * eased;
+}
+
+/**
+ * Interpolate a position (x, y) using an easing function.
+ */
+export function interpolatePosition(from, to, progress, easingFn = easing.easeOutCubic) {
+  return {
+    x: interpolate(from.x, to.x, progress, easingFn),
+    y: interpolate(from.y, to.y, progress, easingFn)
+  };
+}

package/lib/module/icons/benchmark-icon.js

@@ -1 +1,15 @@
-"use strict";import{createIcon}from"./icon-renderer.js";import{benchmarkIconData,BENCHMARK_ICON_COLOR}from"./icon-data.js";export{BENCHMARK_ICON_COLOR};export const BenchmarkIcon=createIcon(benchmarkIconData);
+"use strict";
+
+/**
+ * BenchmarkIcon - Data-driven icon
+ *
+ * The icon is defined as pure data in icon-data.ts
+ * The renderer transforms it to components.
+ *
+ * To change: edit benchmarkIconData in icon-data.ts
+ */
+
+import { createIcon } from "./icon-renderer.js";
+import { benchmarkIconData, BENCHMARK_ICON_COLOR } from "./icon-data.js";
+export { BENCHMARK_ICON_COLOR };
+export const BenchmarkIcon = createIcon(benchmarkIconData);

package/lib/module/icons/env-icon.js

@@ -1 +1,15 @@
-"use strict";import{createIcon}from"./icon-renderer.js";import{envIconData,ENV_ICON_COLOR}from"./icon-data.js";export{ENV_ICON_COLOR};export const EnvIcon=createIcon(envIconData);
+"use strict";
+
+/**
+ * EnvIcon - Data-driven icon
+ *
+ * The icon is defined as pure data in icon-data.ts
+ * The renderer transforms it to components.
+ *
+ * To change: edit envIconData in icon-data.ts
+ */
+
+import { createIcon } from "./icon-renderer.js";
+import { envIconData, ENV_ICON_COLOR } from "./icon-data.js";
+export { ENV_ICON_COLOR };
+export const EnvIcon = createIcon(envIconData);

package/lib/module/icons/events-icon.js

@@ -1 +1,15 @@
-"use strict";import{createIcon}from"./icon-renderer.js";import{eventsIconData,EVENTS_ICON_COLOR}from"./icon-data.js";export{EVENTS_ICON_COLOR};export const EventsIcon=createIcon(eventsIconData);
+"use strict";
+
+/**
+ * EventsIcon - Data-driven icon
+ *
+ * The icon is defined as pure data in icon-data.ts
+ * The renderer transforms it to components.
+ *
+ * To change: edit eventsIconData in icon-data.ts
+ */
+
+import { createIcon } from "./icon-renderer.js";
+import { eventsIconData, EVENTS_ICON_COLOR } from "./icon-data.js";
+export { EVENTS_ICON_COLOR };
+export const EventsIcon = createIcon(eventsIconData);

package/lib/module/icons/highlight-icon.js

@@ -1 +1,15 @@
-"use strict";import{createIcon}from"./icon-renderer.js";import{highlightIconData,HIGHLIGHT_ICON_COLOR}from"./icon-data.js";export{HIGHLIGHT_ICON_COLOR};export const HighlightIcon=createIcon(highlightIconData);
+"use strict";
+
+/**
+ * HighlightIcon - Data-driven icon (also known as StackPulseIcon/RenderPulseIcon)
+ *
+ * The icon is defined as pure data in icon-data.ts
+ * The renderer transforms it to components.
+ *
+ * To change: edit highlightIconData in icon-data.ts
+ */
+
+import { createIcon } from "./icon-renderer.js";
+import { highlightIconData, HIGHLIGHT_ICON_COLOR } from "./icon-data.js";
+export { HIGHLIGHT_ICON_COLOR };
+export const HighlightIcon = createIcon(highlightIconData);