@cahyo-dimas/freeday 1.14.0 → 1.16.0

package/adapters/blazor/TableModel.cs

@@ -0,0 +1,196 @@
+using System.Collections.Concurrent;
+using System.Globalization;
+using System.Reflection;
+using System.Text.RegularExpressions;
+
+namespace Freeday.Blazor;
+
+/// <summary>
+/// The sort / filter / paginate logic for <see cref="FdyTable{TRow}"/> — the C# counterpart of the
+/// framework-agnostic adapters/core/table-model.js shared by the Vue and React adapters. Kept as a
+/// separate pure-function class (no rendering, no state) so it mirrors that reference faithfully and
+/// stays unit-testable. Every method is pure: inputs are never mutated (rows are copied before sort).
+/// </summary>
+public static class TableModel
+{
+    private static readonly ConcurrentDictionary<(Type, string), PropertyInfo?> PropCache = new();
+    private static readonly Regex NonNumeric = new(@"[^\d.-]", RegexOptions.Compiled);
+
+    /// <summary>Numeric value, tolerant of formatted strings ("Rp 1.000"); non-numeric -> 0.</summary>
+    private static double ToNumber(object? v)
+    {
+        if (v is null) return 0;
+        if (v is double d) return double.IsFinite(d) ? d : 0;
+        if (v is IConvertible && v is not string)
+        {
+            try { return Convert.ToDouble(v, CultureInfo.InvariantCulture); } catch { /* fall through */ }
+        }
+        string cleaned = NonNumeric.Replace(v.ToString() ?? string.Empty, string.Empty);
+        return double.TryParse(cleaned, NumberStyles.Any, CultureInfo.InvariantCulture, out double n) ? n : 0;
+    }
+
+    /// <summary>Epoch ms; unparseable -> 0.</summary>
+    private static double ToTime(object? v)
+    {
+        if (v is null) return 0;
+        if (v is DateTime dt) return new DateTimeOffset(dt.ToUniversalTime()).ToUnixTimeMilliseconds();
+        if (v is DateTimeOffset dto) return dto.ToUnixTimeMilliseconds();
+        return DateTimeOffset.TryParse(v.ToString(), CultureInfo.InvariantCulture, DateTimeStyles.AssumeUniversal, out DateTimeOffset parsed)
+            ? parsed.ToUnixTimeMilliseconds()
+            : 0;
+    }
+
+    /// <summary>ISO calendar day (yyyy-MM-dd) — lexicographically comparable.</summary>
+    private static string DateOnly(object? v)
+    {
+        if (v is DateTime dt) return dt.ToString("yyyy-MM-dd", CultureInfo.InvariantCulture);
+        if (v is DateTimeOffset dto) return dto.ToString("yyyy-MM-dd", CultureInfo.InvariantCulture);
+        string s = v?.ToString() ?? string.Empty;
+        return s.Length >= 10 ? s[..10] : s;
+    }
+
+    /// <summary>Raw cell value for a column: the accessor if present, else the property named Key.</summary>
+    public static object? CellValue<TRow>(TRow row, FdyTableColumn<TRow> column)
+    {
+        if (column.Value is not null) return column.Value(row);
+        PropertyInfo? prop = PropCache.GetOrAdd((typeof(TRow), column.Key),
+            static k => k.Item1.GetProperty(k.Item2, BindingFlags.Public | BindingFlags.Instance | BindingFlags.IgnoreCase));
+        return prop?.GetValue(row);
+    }
+
+    /// <summary>Cell value as trimmed display text (null -> "").</summary>
+    public static string CellText<TRow>(TRow row, FdyTableColumn<TRow> column)
+    {
+        object? v = CellValue(row, column);
+        return v is null ? string.Empty : (Convert.ToString(v, CultureInfo.CurrentCulture) ?? string.Empty).Trim();
+    }
+
+    /// <summary>Effective comparator type: explicit SortType, else derived from the filter type.</summary>
+    public static FdyColumnType ColumnSortType<TRow>(FdyTableColumn<TRow> column)
+    {
+        if (column.SortType is { } t) return t;
+        return column.Filter switch
+        {
+            FdyColumnFilterType.Number => FdyColumnType.Number,
+            FdyColumnFilterType.Date => FdyColumnType.Date,
+            _ => FdyColumnType.Text,
+        };
+    }
+
+    /// <summary>Ascending comparison of two raw cell values under a comparator type.</summary>
+    public static int CompareBy(FdyColumnType type, object? a, object? b) => type switch
+    {
+        FdyColumnType.Number => ToNumber(a).CompareTo(ToNumber(b)),
+        FdyColumnType.Date => ToTime(a).CompareTo(ToTime(b)),
+        _ => string.Compare(a?.ToString() ?? string.Empty, b?.ToString() ?? string.Empty,
+            StringComparison.CurrentCultureIgnoreCase),
+    };
+
+    /// <summary>True when a filter would actually narrow the rows (worth applying / showing as active).</summary>
+    public static bool IsFilterActive(FdyColumnFilter? filter) => filter switch
+    {
+        FdyColumnFilter.Text t => t.Value.Trim().Length > 0,
+        FdyColumnFilter.Enum e => e.Values.Count > 0,
+        FdyColumnFilter.Number n => n.Min is not null || n.Max is not null,
+        FdyColumnFilter.Date d => d.From is not null || d.To is not null,
+        _ => false,
+    };
+
+    private static bool RowPassesFilter<TRow>(TRow row, FdyTableColumn<TRow> column, FdyColumnFilter filter)
+    {
+        switch (filter)
+        {
+            case FdyColumnFilter.Text t:
+            {
+                string needle = t.Value.Trim().ToLowerInvariant();
+                return needle.Length == 0 || CellText(row, column).ToLowerInvariant().Contains(needle);
+            }
+            case FdyColumnFilter.Enum e:
+                return e.Values.Count == 0 || e.Values.Contains(CellText(row, column));
+            case FdyColumnFilter.Number n:
+            {
+                double v = ToNumber(CellValue(row, column));
+                if (n.Min is { } min && v < min) return false;
+                if (n.Max is { } max && v > max) return false;
+                return true;
+            }
+            case FdyColumnFilter.Date d:
+            {
+                string day = DateOnly(CellValue(row, column));
+                if (d.From is { } from && string.CompareOrdinal(day, from) < 0) return false;
+                if (d.To is { } to && string.CompareOrdinal(day, to) > 0) return false;
+                return true;
+            }
+            default:
+                return true;
+        }
+    }
+
+    /// <summary>Rows passing every active column filter (logical AND). Input is never mutated.</summary>
+    public static List<TRow> FilterRows<TRow>(
+        IReadOnlyList<TRow> rows,
+        IReadOnlyList<FdyTableColumn<TRow>> columns,
+        IReadOnlyDictionary<string, FdyColumnFilter> filters)
+    {
+        List<(FdyTableColumn<TRow> Col, FdyColumnFilter Filter)> active = new();
+        foreach (FdyTableColumn<TRow> col in columns)
+        {
+            if (filters.TryGetValue(col.Key, out FdyColumnFilter? f) && IsFilterActive(f))
+            {
+                active.Add((col, f));
+            }
+        }
+        if (active.Count == 0) return rows.ToList();
+        return rows.Where(row => active.All(e => RowPassesFilter(row, e.Col, e.Filter))).ToList();
+    }
+
+    /// <summary>Rows sorted by the given sort state. Stable via OrderBy; input is never mutated.</summary>
+    public static List<TRow> SortRows<TRow>(
+        IReadOnlyList<TRow> rows,
+        IReadOnlyList<FdyTableColumn<TRow>> columns,
+        FdySortState? sort)
+    {
+        if (sort is null) return rows.ToList();
+        FdyTableColumn<TRow>? column = columns.FirstOrDefault(c => c.Key == sort.Key);
+        if (column is null) return rows.ToList();
+        FdyColumnType type = ColumnSortType(column);
+        int factor = sort.Dir == FdySortDir.Desc ? -1 : 1;
+        return rows
+            .OrderBy(r => r, Comparer<TRow>.Create((a, b) => CompareBy(type, CellValue(a, column), CellValue(b, column)) * factor))
+            .ToList();
+    }
+
+    /// <summary>Page slice (0-based page index). A non-positive size returns all rows.</summary>
+    public static List<TRow> Paginate<TRow>(IReadOnlyList<TRow> rows, int pageIndex, int pageSize)
+    {
+        if (pageSize <= 0) return rows.ToList();
+        return rows.Skip(pageIndex * pageSize).Take(pageSize).ToList();
+    }
+
+    /// <summary>Distinct non-empty cell texts for a column, naturally sorted — the enum-filter source.</summary>
+    public static List<string> DistinctValues<TRow>(IReadOnlyList<TRow> rows, FdyTableColumn<TRow> column)
+    {
+        HashSet<string> seen = new();
+        List<string> outList = new();
+        foreach (TRow row in rows)
+        {
+            string v = CellText(row, column);
+            if (v.Length > 0 && seen.Add(v)) outList.Add(v);
+        }
+        outList.Sort((a, b) => string.Compare(a, b, StringComparison.CurrentCultureIgnoreCase));
+        return outList;
+    }
+
+    /// <summary>Page-number window: first and last page always shown, current ±1, null for the
+    /// "ellipsis" gaps between. <paramref name="current"/> and returned page numbers are 1-based.</summary>
+    public static List<int?> PageWindow(int current, int totalPages)
+    {
+        List<int?> outList = new();
+        for (int p = 1; p <= totalPages; p++)
+        {
+            if (p == 1 || p == totalPages || (p >= current - 1 && p <= current + 1)) outList.Add(p);
+            else if (outList.Count == 0 || outList[^1] is not null) outList.Add(null);
+        }
+        return outList;
+    }
+}

package/adapters/blazor/TableTypes.cs

@@ -0,0 +1,69 @@
+using Microsoft.AspNetCore.Components;
+
+namespace Freeday.Blazor;
+
+/// <summary>Sort direction for a column.</summary>
+public enum FdySortDir { Asc, Desc }
+
+/// <summary>A column's comparator type — how its values are ordered when sorting.</summary>
+public enum FdyColumnType { Text, Number, Date }
+
+/// <summary>Cell alignment. Maps to <c>text-align</c> on the header and body cells.</summary>
+public enum FdyColumnAlign { Left, Right, Center }
+
+/// <summary>The kind of column filter to offer (a funnel popover in the header).</summary>
+public enum FdyColumnFilterType { Text, Enum, Number, Date }
+
+/// <summary>Which column is sorted and in what direction.</summary>
+public sealed record FdySortState(string Key, FdySortDir Dir);
+
+/// <summary>Server-driven pagination state (0-based page index). Its presence on
+/// <see cref="FdyTable{TRow}.Page"/> switches the table into server mode.</summary>
+public sealed record FdyPageState(int Index, int Size, int Total);
+
+/// <summary>The active filter for a single column (a closed set of shapes, one per filter type).</summary>
+public abstract record FdyColumnFilter
+{
+    public sealed record Text(string Value) : FdyColumnFilter;
+    public sealed record Enum(IReadOnlyList<string> Values) : FdyColumnFilter;
+    public sealed record Number(double? Min, double? Max) : FdyColumnFilter;
+    public sealed record Date(string? From, string? To) : FdyColumnFilter;
+}
+
+/// <summary>One column definition. <typeparamref name="TRow"/> is the row type.</summary>
+/// <typeparam name="TRow">The row model.</typeparam>
+public sealed class FdyTableColumn<TRow>
+{
+    /// <summary>Row property key; the sort/filter identity and, when <see cref="Value"/> is unset,
+    /// the default cell accessor (resolved by reflection against a property of this name).</summary>
+    public required string Key { get; init; }
+
+    /// <summary>Header label.</summary>
+    public required string Label { get; init; }
+
+    /// <summary>Show a sort toggle in the header.</summary>
+    public bool Sortable { get; init; }
+
+    /// <summary>Offer a column filter of this type (null = no filter).</summary>
+    public FdyColumnFilterType? Filter { get; init; }
+
+    /// <summary>Cell alignment (null = left).</summary>
+    public FdyColumnAlign? Align { get; init; }
+
+    /// <summary>Render cells in the monospace data font (<c>.fdy-mono</c>).</summary>
+    public bool Mono { get; init; }
+
+    /// <summary>Override the comparator type; defaults to one derived from <see cref="Filter"/>, else Text.</summary>
+    public FdyColumnType? SortType { get; init; }
+
+    /// <summary>Typed value accessor for sort/filter/default cell text; defaults to the property named
+    /// <see cref="Key"/> (reflection). Prefer setting this for strongly-typed, allocation-free access.</summary>
+    public Func<TRow, object?>? Value { get; init; }
+
+    /// <summary>Explicit options for an enum filter; defaults to the distinct values in the current
+    /// rows. Provide this in server-paged mode, where the rows on screen are only one page.</summary>
+    public IReadOnlyList<string>? Options { get; init; }
+
+    /// <summary>Custom cell template; defaults to the accessor's text.</summary>
+    public RenderFragment<TRow>? Cell { get; init; }
+}

package/adapters/blazor/_Imports.razor

@@ -0,0 +1,5 @@
+@using System.Threading.Tasks
+@using Microsoft.AspNetCore.Components
+@using Microsoft.AspNetCore.Components.Web
+@using Microsoft.JSInterop
+@using Freeday.Blazor

package/adapters/blazor/freeday-blazor.js

@@ -55,11 +55,44 @@
     return token;
   }
 
-  // Remove a subscription created by on().
+  // Subscribe to a daterange's child datepicker changes, forwarding {value, role} so a Blazor
+  // wrapper can bind From/To separately — both children emit the same fdy-datepicker-change, so
+  // the originating child's data-role is what tells them apart.
+  function dateRangeOn(element, dotNetRef, methodName) {
+    var handler = function (e) {
+      var origin = e.target && e.target.closest ? e.target.closest('[data-role]') : null;
+      dotNetRef.invokeMethodAsync(methodName, {
+        value: (e.detail && e.detail.value) || '',
+        role: origin ? origin.getAttribute('data-role') : null
+      });
+    };
+    element.addEventListener('fdy-datepicker-change', handler);
+    var token = ++seq;
+    subs[token] = { el: element, type: 'fdy-datepicker-change', fn: handler };
+    return token;
+  }
+
+  // Fire a .NET callback when a pointerdown lands outside `element`, or Escape is pressed —
+  // the light-dismiss primitive for Blazor-owned popovers (e.g. FdyTable's column filter, which
+  // is position:fixed in the top layer and so escapes the table's overflow). Returns an off() token.
+  function onOutside(element, dotNetRef, methodName) {
+    if (!element) return 0;
+    var onPointer = function (e) { if (!element.contains(e.target)) dotNetRef.invokeMethodAsync(methodName); };
+    var onKey = function (e) { if (e.key === 'Escape') dotNetRef.invokeMethodAsync(methodName); };
+    document.addEventListener('pointerdown', onPointer, true);
+    document.addEventListener('keydown', onKey, true);
+    var token = ++seq;
+    subs[token] = { el: document, type: 'pointerdown', fn: onPointer, key: onKey, capture: true };
+    return token;
+  }
+
+  // Remove a subscription created by on() / onOutside(); removes with the same capture flag it
+  // was added with (a bubble-phase listener can't be removed with capture:true and vice versa).
   function off(token) {
     var s = subs[token];
     if (s) {
-      s.el.removeEventListener(s.type, s.fn);
+      s.el.removeEventListener(s.type, s.fn, s.capture === true);
+      if (s.key) s.el.removeEventListener('keydown', s.key, true);
       delete subs[token];
     }
   }
@@ -69,11 +102,76 @@
     if (window.Freeday && typeof window.Freeday.toast === 'function') window.Freeday.toast(options);
   }
 
+  // Passthrough to a combo's programmatic setter (window.FreedayCombo.setValue) so a
+  // Blazor @bind-Value can push an external value change onto the enhancer-owned DOM
+  // without the enhancer echoing an fdy-change back.
+  function comboSetValue(element, value) {
+    if (window.FreedayCombo && typeof window.FreedayCombo.setValue === 'function') {
+      window.FreedayCombo.setValue(element, value);
+    }
+  }
+
+  // Repaint a chart from its current data-* attributes. FdyChart keeps the outer <div> +
+  // attributes under Blazor's control and calls this after each render, so the SVG re-renders
+  // when the bound data changes (window.FreedayChart.update === renderChart).
+  function chartUpdate(element) {
+    if (element && window.FreedayChart && typeof window.FreedayChart.update === 'function') {
+      window.FreedayChart.update(element);
+    }
+  }
+
+  // --- Native <dialog> control for FdyModal ---------------------------------
+  // The kit styles `.fdy-modal` as a <dialog> but nothing drives it; Blazor can't call
+  // showModal()/close() from C#, and Esc/backdrop dismissal must route through .NET state
+  // (not close the DOM behind its back). dialogInit wires cancel + backdrop → a [JSInvokable]
+  // dismiss callback; showModal()/close() are guarded (showModal on an open dialog throws).
+  var dialogSubs = {};
+  var dialogSeq = 0;
+
+  function dialogInit(dialog, dotNetRef, dismissMethod, dismissible) {
+    if (!dialog) return 0;
+    var onCancel = function (e) {
+      e.preventDefault(); // stop the native close; app state is the single source of truth
+      if (dismissible) dotNetRef.invokeMethodAsync(dismissMethod);
+    };
+    var onClick = function (e) {
+      // The ::backdrop is not a separate element — a click whose target is the dialog box
+      // itself (not its content) is a backdrop click.
+      if (dismissible && e.target === dialog) dotNetRef.invokeMethodAsync(dismissMethod);
+    };
+    dialog.addEventListener('cancel', onCancel);
+    dialog.addEventListener('click', onClick);
+    var token = ++dialogSeq;
+    dialogSubs[token] = { el: dialog, cancel: onCancel, click: onClick };
+    return token;
+  }
+
+  function dialogShow(dialog) {
+    if (dialog && typeof dialog.showModal === 'function' && !dialog.open) dialog.showModal();
+  }
+
+  function dialogClose(dialog) {
+    if (dialog && dialog.open) dialog.close();
+  }
+
+  function dialogDispose(token) {
+    var s = dialogSubs[token];
+    if (s) {
+      s.el.removeEventListener('cancel', s.cancel);
+      s.el.removeEventListener('click', s.click);
+      delete dialogSubs[token];
+    }
+  }
+
   // Flip the document theme (data-theme on <html>), for the demo toggle.
   function toggleTheme() {
     var e = document.documentElement;
     e.setAttribute('data-theme', e.getAttribute('data-theme') === 'dark' ? 'light' : 'dark');
   }
 
-  window.FreedayBlazor = { initAll: initAll, on: on, off: off, toast: toast, toggleTheme: toggleTheme };
+  window.FreedayBlazor = {
+    initAll: initAll, on: on, off: off, onOutside: onOutside, toast: toast, toggleTheme: toggleTheme,
+    comboSetValue: comboSetValue, dateRangeOn: dateRangeOn, chartUpdate: chartUpdate,
+    dialogInit: dialogInit, dialogShow: dialogShow, dialogClose: dialogClose, dialogDispose: dialogDispose,
+  };
 })();

package/dist/asset.d.ts

@@ -0,0 +1,6 @@
+// Shared type stub for every export imported purely for its side effects — the CSS
+// bundles (`./css`, `./css/components`, `./tokens`) and the individual enhancer scripts
+// (`./enhancers/*`). TypeScript only needs the `types` condition to *resolve* the module;
+// there is no value surface to describe. (The root `.` import is different — it augments
+// window.Freeday — so it points at ./freeday.d.ts instead.)
+export {};

package/dist/freeday-select.js

@@ -91,7 +91,11 @@
       setHighlight(-1);
       if (openClose === close) openClose = null;
     }
-    function choose(opt) {
+    // Mark an option selected + reflect it in the button. `silent` skips the change
+    // event, close, and focus — used by the programmatic setValue() below so a host
+    // (e.g. a Blazor/framework wrapper) can push a value in without echoing an event
+    // back to itself or stealing focus. User-driven picks go through choose() (loud).
+    function select(opt, silent) {
       options.forEach(function (other) {
         var on = other === opt;
         other.setAttribute('aria-selected', on ? 'true' : 'false');
@@ -101,12 +105,24 @@
       root.setAttribute('data-value', opt.getAttribute('data-value') || '');
       valueEl.textContent = optionLabel(opt);
       valueEl.classList.remove('fdy-combo__value--placeholder');
-      root.dispatchEvent(new CustomEvent('fdy-change', {
-        bubbles: true,
-        detail: { value: opt.getAttribute('data-value') }
-      }));
-      close();
-      button.focus();
+      if (!silent) {
+        root.dispatchEvent(new CustomEvent('fdy-change', {
+          bubbles: true,
+          detail: { value: opt.getAttribute('data-value') }
+        }));
+        close();
+        button.focus();
+      }
+    }
+    function choose(opt) { select(opt, false); }
+    // Programmatic set (no event, no focus change). No-op if no option matches.
+    function setValue(value) {
+      for (var i = 0; i < options.length; i++) {
+        if ((options[i].getAttribute('data-value') || '') === String(value)) {
+          select(options[i], true);
+          return;
+        }
+      }
     }
 
     button.addEventListener('click', function () {
@@ -167,6 +183,9 @@
     root.addEventListener('focusout', function (e) {
       if (!root.contains(e.relatedTarget)) close();
     });
+
+    // Per-instance API for programmatic control (host wrappers / two-way binding).
+    root._fdyCombo = { setValue: setValue };
   }
 
   function initAll(context) {
@@ -190,5 +209,10 @@
     initAll();
   }
 
-  window.FreedayCombo = { init: initCombo, initAll: initAll };
+  // Programmatic set on an already-initialised combo root (no fdy-change dispatched).
+  function setValue(root, value) {
+    if (root && root._fdyCombo) root._fdyCombo.setValue(value);
+  }
+
+  window.FreedayCombo = { init: initCombo, initAll: initAll, setValue: setValue };
 })();

package/dist/freeday.d.ts

@@ -0,0 +1,24 @@
+// Type surface for the root side-effect import `@cahyo-dimas/freeday`, which loads every
+// enhancer and registers the `window.Freeday` global. Authored from src/freeday-toast.js
+// — keep in sync with it. (The per-component window.Freeday<Name> enhancer namespaces are
+// intentionally not typed here; no consumer reconstructs those.)
+
+export interface FreedayToastOptions {
+  /** Accent + ARIA role. Omitted = neutral. 'danger' uses role="alert"; the rest role="status". */
+  variant?: 'success' | 'warning' | 'danger' | 'info';
+  title?: string;
+  message?: string;
+  /** Milliseconds before auto-dismiss. Default 4000; 0 = sticky. */
+  timeout?: number;
+}
+
+export interface FreedayGlobal {
+  /** Show a transient toast in a live region (created on first use). Returns the toast element. */
+  toast(opts?: FreedayToastOptions): HTMLElement;
+}
+
+declare global {
+  interface Window {
+    Freeday?: FreedayGlobal;
+  }
+}

package/dist/freeday.js

@@ -2340,7 +2340,11 @@
       setHighlight(-1);
       if (openClose === close) openClose = null;
     }
-    function choose(opt) {
+    // Mark an option selected + reflect it in the button. `silent` skips the change
+    // event, close, and focus — used by the programmatic setValue() below so a host
+    // (e.g. a Blazor/framework wrapper) can push a value in without echoing an event
+    // back to itself or stealing focus. User-driven picks go through choose() (loud).
+    function select(opt, silent) {
       options.forEach(function (other) {
         var on = other === opt;
         other.setAttribute('aria-selected', on ? 'true' : 'false');
@@ -2350,12 +2354,24 @@
       root.setAttribute('data-value', opt.getAttribute('data-value') || '');
       valueEl.textContent = optionLabel(opt);
       valueEl.classList.remove('fdy-combo__value--placeholder');
-      root.dispatchEvent(new CustomEvent('fdy-change', {
-        bubbles: true,
-        detail: { value: opt.getAttribute('data-value') }
-      }));
-      close();
-      button.focus();
+      if (!silent) {
+        root.dispatchEvent(new CustomEvent('fdy-change', {
+          bubbles: true,
+          detail: { value: opt.getAttribute('data-value') }
+        }));
+        close();
+        button.focus();
+      }
+    }
+    function choose(opt) { select(opt, false); }
+    // Programmatic set (no event, no focus change). No-op if no option matches.
+    function setValue(value) {
+      for (var i = 0; i < options.length; i++) {
+        if ((options[i].getAttribute('data-value') || '') === String(value)) {
+          select(options[i], true);
+          return;
+        }
+      }
     }
 
     button.addEventListener('click', function () {
@@ -2416,6 +2432,9 @@
     root.addEventListener('focusout', function (e) {
       if (!root.contains(e.relatedTarget)) close();
     });
+
+    // Per-instance API for programmatic control (host wrappers / two-way binding).
+    root._fdyCombo = { setValue: setValue };
   }
 
   function initAll(context) {
@@ -2439,7 +2458,12 @@
     initAll();
   }
 
-  window.FreedayCombo = { init: initCombo, initAll: initAll };
+  // Programmatic set on an already-initialised combo root (no fdy-change dispatched).
+  function setValue(root, value) {
+    if (root && root._fdyCombo) root._fdyCombo.setValue(value);
+  }
+
+  window.FreedayCombo = { init: initCombo, initAll: initAll, setValue: setValue };
 })();
 
 /* Freeday — slider value binding (optional, zero-dependency).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cahyo-dimas/freeday",
-  "version": "1.14.0",
+  "version": "1.16.0",
   "description": "Freeday — token-driven, framework-agnostic UI KIT (design source-of-truth).",
   "type": "module",
   "license": "MIT",
@@ -25,17 +25,18 @@
     "adapters",
     "tokens/tokens.json",
     "tokens/breakpoints.mjs",
+    "tokens/breakpoints.d.ts",
     "README.md",
     "README.id.md",
     "CHANGELOG.md"
   ],
   "exports": {
-    ".": "./dist/freeday.js",
-    "./css": "./dist/freeday.bundle.css",
-    "./css/components": "./dist/freeday.css",
-    "./tokens": "./dist/freeday.tokens.css",
-    "./breakpoints": "./tokens/breakpoints.mjs",
-    "./enhancers/*": "./dist/freeday-*.js",
+    ".": { "types": "./dist/freeday.d.ts", "default": "./dist/freeday.js" },
+    "./css": { "types": "./dist/asset.d.ts", "default": "./dist/freeday.bundle.css" },
+    "./css/components": { "types": "./dist/asset.d.ts", "default": "./dist/freeday.css" },
+    "./tokens": { "types": "./dist/asset.d.ts", "default": "./dist/freeday.tokens.css" },
+    "./breakpoints": { "types": "./tokens/breakpoints.d.ts", "default": "./tokens/breakpoints.mjs" },
+    "./enhancers/*": { "types": "./dist/asset.d.ts", "default": "./dist/freeday-*.js" },
     "./vue": {
       "types": "./adapters/vue/index.d.ts",
       "default": "./adapters/vue/index.js"
@@ -62,12 +63,17 @@
   "scripts": {
     "build": "node tokens/build.mjs",
     "test": "node --test",
+    "test:browser": "node --test browser/vanilla.mjs browser/adapter.mjs",
     "prepack": "node tokens/build.mjs",
     "version": "node tokens/build.mjs && git add dist",
     "typecheck:react": "tsc -p adapters/react/tsconfig.json --noEmit"
   },
   "devDependencies": {
     "@types/react": "^19.2.17",
-    "typescript": "^7.0.2"
+    "esbuild": "^0.28.1",
+    "react": "^19.2.8",
+    "react-dom": "^19.2.8",
+    "typescript": "^7.0.2",
+    "vue": "^3.5.40"
   }
 }