reke-ui 0.1.2 → 0.2.1

package/README.md

@@ -106,6 +106,8 @@ function App() {
 }
 ```
 
+> **Components with render props** (e.g. `Table` with `expandedRowRender` or `columns[].render`) use a React-native bridge: return `ReactNode` (JSX), pass `getRowKey` for stable keying, and never `import { html } from 'lit'` in app code. See `README-DOC.md` → reke-table → React usage, or install the agent skills below for the full contract.
+
 ### Vanilla JS
 
 ```html
@@ -146,6 +148,25 @@ Override any CSS custom property to match your brand:
 
 See all available tokens in [`src/tokens/reke-tokens.css`](src/tokens/reke-tokens.css).
 
+## Agent skills
+
+reke-ui ships **LLM-first skills** that teach AI coding agents how to consume the library correctly (3-layer token system, component APIs, React bridge contract for components with render props).
+
+```bash
+npm install reke-ui
+npx reke-ui install-skills
+```
+
+This copies three consumer skills into your project's `.claude/skills/` directory:
+
+- `reke-ui-consumer` — install, imports, framework integration, full component reference, React bridge contract
+- `reke-design-system` — 3-layer token architecture for Tailwind v4 projects (microfrontend-safe scoping)
+- `reke-bridge` — when and how to bridge web components to your framework (React today; pattern documented for Vue/Svelte)
+
+After install, ask your agent to refresh its skill index: **"update skill registry"** (or **"actualizá las skills"**). The agent will then know how to use reke-ui idiomatically — no more guessing or copy-pasted anti-patterns.
+
+Options: `--force` reinstalls even if versions match, `--dry-run` previews without writing files.
+
 ## Development
 
 ```bash

package/cli/install-skills.mjs

@@ -0,0 +1,169 @@
+#!/usr/bin/env node
+/**
+ * reke-ui install-skills
+ *
+ * Copies consumer-facing agent skills (LLM instructions) from this package
+ * into the current project's `.claude/skills/` directory, so any AI agent
+ * working in that project knows how to consume reke-ui correctly.
+ *
+ * Why this exists:
+ * reke-ui ships agent skills (.claude/skills/) that document its consumer
+ * API, the React bridge contract, and the 3-layer token system. These skills
+ * are LLM-first instructions — they only help when they live in a directory
+ * the agent scans. Library `node_modules/.../.claude/skills/` is NEVER
+ * scanned automatically by skill-registry. This CLI puts them where they
+ * belong.
+ *
+ * What it does:
+ *   1. Locates the reke-ui package's bundled `.claude/skills/`.
+ *   2. Copies CONSUMER skills only (not internal-maintainer skills) to
+ *      `<consumer-cwd>/.claude/skills/`.
+ *   3. Writes a marker file with the reke-ui version so we can detect drift.
+ *   4. Prints next-step instructions for the user.
+ *
+ * What it does NOT do:
+ *   - It does not invoke skill-registry. skill-registry is an agent skill,
+ *     not a CLI tool. The user must ask their agent to update the registry
+ *     after install (we print the exact phrase to use).
+ *   - It does not modify package.json, tsconfig, or any project file other
+ *     than files under `.claude/skills/reke-ui-*` and the marker.
+ */
+import { cpSync, existsSync, mkdirSync, readFileSync, writeFileSync, rmSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const SCRIPT_DIR = dirname(fileURLToPath(import.meta.url));
+// Package root is one level up from cli/
+const PKG_ROOT = resolve(SCRIPT_DIR, '..');
+const SOURCE_SKILLS = join(PKG_ROOT, '.claude', 'skills');
+
+// Skills published to consumers. Internal-maintainer skills (lit-expert,
+// reke-component, test-runner, a11y-checker, update-docs) are deliberately
+// excluded — those only help when working ON reke-ui itself.
+const CONSUMER_SKILLS = ['reke-ui-consumer', 'reke-bridge', 'reke-design-system'];
+
+const CWD = process.cwd();
+const TARGET_DIR = join(CWD, '.claude', 'skills');
+const MARKER_FILE = join(CWD, '.claude', '.reke-ui-skills-version');
+
+const args = process.argv.slice(2);
+const FORCE = args.includes('--force') || args.includes('-f');
+const DRY = args.includes('--dry-run') || args.includes('-n');
+
+function log(msg) {
+  process.stdout.write(`${msg}\n`);
+}
+function warn(msg) {
+  process.stderr.write(`\x1b[33m${msg}\x1b[0m\n`);
+}
+function err(msg) {
+  process.stderr.write(`\x1b[31m${msg}\x1b[0m\n`);
+}
+
+function readPkgVersion() {
+  try {
+    const pkg = JSON.parse(readFileSync(join(PKG_ROOT, 'package.json'), 'utf8'));
+    return pkg.version || 'unknown';
+  } catch {
+    return 'unknown';
+  }
+}
+
+function readMarker() {
+  if (!existsSync(MARKER_FILE)) return null;
+  try {
+    return JSON.parse(readFileSync(MARKER_FILE, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function writeMarker(version, skills) {
+  writeFileSync(
+    MARKER_FILE,
+    `${JSON.stringify(
+      {
+        package: 'reke-ui',
+        version,
+        installedAt: new Date().toISOString(),
+        skills,
+      },
+      null,
+      2,
+    )}\n`,
+  );
+}
+
+function installSkill(name, version) {
+  const src = join(SOURCE_SKILLS, name);
+  const dst = join(TARGET_DIR, name);
+  if (!existsSync(src)) {
+    warn(`  ⚠ skill missing in package: ${name} (skipping)`);
+    return false;
+  }
+  if (existsSync(dst) && !FORCE) {
+    const existing = readMarker();
+    const sameVersion = existing && existing.version === version;
+    if (sameVersion) {
+      log(`  = ${name} (already at v${version})`);
+      return false;
+    }
+    log(`  → ${name} (updating from v${existing?.version || '?'} to v${version})`);
+  } else {
+    log(`  + ${name}`);
+  }
+  if (DRY) return true;
+  rmSync(dst, { recursive: true, force: true });
+  cpSync(src, dst, { recursive: true });
+  return true;
+}
+
+function main() {
+  log('\nreke-ui install-skills');
+  log('───────────────────────');
+
+  if (!existsSync(SOURCE_SKILLS)) {
+    err(`error: source skills not found at ${SOURCE_SKILLS}`);
+    err('Is this a corrupted reke-ui install?');
+    process.exit(1);
+  }
+
+  const version = readPkgVersion();
+  log(`reke-ui version : ${version}`);
+  log(`target          : ${TARGET_DIR}`);
+  if (DRY) log('mode            : DRY RUN (no files written)\n');
+  else log('');
+
+  if (!DRY) mkdirSync(TARGET_DIR, { recursive: true });
+
+  log('skills:');
+  const installed = [];
+  for (const name of CONSUMER_SKILLS) {
+    const ok = installSkill(name, version);
+    if (ok) installed.push(name);
+  }
+
+  if (!DRY && installed.length > 0) {
+    writeMarker(version, installed);
+  }
+
+  log('');
+  if (installed.length === 0 && !DRY) {
+    log('Nothing to do — skills already up to date.');
+    log('Run with --force to reinstall.\n');
+    return;
+  }
+
+  log('Next step:');
+  log('  Ask your agent to regenerate the skill registry. Phrase it as:');
+  log('    "actualizá las skills" / "update skill registry"\n');
+  log('Or run any skill-registry-aware command in this project; the agent');
+  log('will pick up the new skills under .claude/skills/reke-ui-*\n');
+}
+
+try {
+  main();
+} catch (e) {
+  err(`fatal: ${e.message || e}`);
+  process.exit(1);
+}

package/custom-elements.json

@@ -2458,9 +2458,19 @@
               "default": "#E5E5E5"
             },
             {
-              "description": "Header text color. Props: - `expandedRowRender`: Lit-based expand render. Receives `(row, index)` → TemplateResult. - `expandedRowElement`: Framework-agnostic expand render. Receives `(host, row, index)` — mount any framework. Return cleanup or void.",
+              "description": "Header text color.",
               "name": "--reke-color-text-muted",
               "default": "#525252"
+            },
+            {
+              "description": "Chevron focus outline color.",
+              "name": "--reke-color-primary",
+              "default": "#22C55E"
+            },
+            {
+              "description": "Chevron button corner radius. Props: - `expandedRowElement`: Framework-agnostic expand render. Receives `(host, row, key)`. Mount any framework. Return cleanup or void. - `getRowKey`: Optional `(row, index) => RowKey`. Defaults to `String(index)`. Use a stable domain id for identity-keyed expand state across sorts. - `expandable`: Opt-in boolean (default `false`). When `true`, `reke-table` prepends a leading toggle column with an accessible chevron `<button>` per row: `aria-expanded` reflects the row's expand state, `aria-controls` points at the expand `<td>`, and `Enter`/`Space` activate the toggle. Consumers can also build their own toggles by leaving `expandable=false` (default) and calling `toggleExpand(key)` directly. - `expandOnRowClick` (attribute `expand-on-row-click`): Opt-in boolean (default `false`). When `true`, clicking anywhere on a row calls `toggleExpand(key)` internally. `reke-row-click` is STILL emitted on every row click. The chevron button calls `stopPropagation()` so chevron clicks do NOT double-toggle. Consumers MUST use EITHER this prop OR their own `reke-row-click` → `toggleExpand` handler, not both. For keyboard / screen-reader users, pair with `expandable`.",
+              "name": "--reke-radius",
+              "default": "4px"
             }
           ],
           "cssParts": [
@@ -2503,6 +2513,14 @@
             {
               "description": "The td spanning all columns in the expanded row.",
               "name": "expand-content"
+            },
+            {
+              "description": "The leading `<td>` that contains the chevron button (only when `expandable`).",
+              "name": "expand-toggle-cell"
+            },
+            {
+              "description": "The chevron `<button>` itself (only when `expandable`).",
+              "name": "expand-toggle-button"
             }
           ],
           "slots": [
@@ -2586,6 +2604,28 @@
               "attribute": "borderless",
               "reflects": true
             },
+            {
+              "kind": "field",
+              "name": "expandable",
+              "type": {
+                "text": "boolean"
+              },
+              "default": "false",
+              "description": "Opt-in: when `true`, the table prepends a leading toggle column whose\n`<button>` calls `toggleExpand(key)`, exposes `aria-expanded` reflecting\nthe expand state, `aria-controls` pointing at the expand `<td>` id\n(`reke-table-expand-<key>`), and accepts `Enter` / `Space` activation.\n\nDefaults to `false` so consumers that already wire their own toggles\n(chips, links, custom buttons) are unaffected.",
+              "attribute": "expandable",
+              "reflects": true
+            },
+            {
+              "kind": "field",
+              "name": "expandOnRowClick",
+              "type": {
+                "text": "boolean"
+              },
+              "default": "false",
+              "description": "Opt-in: when `true`, clicking anywhere on a row (outside the chevron, if\npresent) calls `toggleExpand(key)` internally using the row's identity\nkey. The `reke-row-click` event is STILL emitted on every row click so\nconsumers can react in addition to the built-in toggle.\n\nDefault is `false` to preserve non-breaking behavior: existing consumers\nthat wire their own `reke-row-click` → `toggleExpand` handlers are\nunaffected.\n\nA11y note: row clicks are a pointer convenience only. The `<tr>` does NOT\nreceive `role=\"button\"` or `tabindex` (that would be a clickable-row\na11y anti-pattern). For keyboard / screen-reader users, pair this prop\nwith `expandable` so the accessible chevron `<button>` is available.\n\nDouble-wiring caveat: consumers MUST use EITHER `expandOnRowClick` OR\ntheir own `reke-row-click` → `toggleExpand` handler — not both — or the\nrow will toggle twice and net to no change.\n\nChevron interaction: the chevron `<button>` calls `stopPropagation()`, so\nclicking the chevron does NOT trigger the row-click toggle (no double\ntoggle).",
+              "attribute": "expand-on-row-click",
+              "reflects": true
+            },
             {
               "kind": "field",
               "name": "sortKey",
@@ -2608,36 +2648,81 @@
             },
             {
               "kind": "field",
-              "name": "expandedRowRender",
+              "name": "expandedRowElement",
               "type": {
-                "text": "ExpandedRowRenderer | null"
+                "text": "ExpandedRowElement | null"
               },
               "default": "null",
-              "description": "When set, rows become expandable with a chevron toggle."
+              "description": "Framework-agnostic expand callback. Sole expand API."
             },
             {
               "kind": "field",
-              "name": "expandedRowElement",
+              "name": "getRowKey",
               "type": {
-                "text": "((host: HTMLElement, row: TableRow, index: number) => (() => void) | void) | null"
+                "text": "GetRowKey | undefined"
               },
-              "default": "null",
-              "description": "Framework-agnostic alternative to expandedRowRender.\nReceives an HTMLElement host — mount any framework's content into it.\nReturn a cleanup function (called on collapse) or void."
+              "description": "Resolve a stable identifier for each row.\nDefaults to `String(index)` — identity-equivalent only when rows are stable.\nProvide a domain id (e.g. `row => row.id`) to keep expand state across sorts."
             },
             {
               "kind": "field",
               "name": "expandedRows",
               "type": {
-                "text": "Set<number>"
+                "text": "Set<RowKey>"
               },
               "default": "new Set()",
-              "description": "Set of row indices currently expanded."
+              "description": "Set of row keys currently expanded."
             },
             {
               "kind": "field",
-              "name": "_expandCleanups",
+              "name": "_hostCache",
               "privacy": "private",
-              "default": "new Map<number, () => void>()"
+              "default": "new Map<RowKey, HTMLElement>()",
+              "description": "Host element cached per row key. Survives unrelated re-renders."
+            },
+            {
+              "kind": "field",
+              "name": "_cleanupMap",
+              "privacy": "private",
+              "default": "new Map<RowKey, Cleanup>()",
+              "description": "Cleanup cached per row key. Invoked exactly once on collapse / row removal / disconnect."
+            },
+            {
+              "kind": "field",
+              "name": "_warnedDupKeys",
+              "privacy": "private",
+              "default": "new Set<RowKey>()",
+              "description": "Keys we have already warned about as duplicates (one-shot per component lifetime)."
+            },
+            {
+              "kind": "field",
+              "name": "_warnedNumericTarget",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "private",
+              "default": "false",
+              "description": "One-shot guard for the numeric-target-with-getRowKey ambiguity warning."
+            },
+            {
+              "kind": "field",
+              "name": "_mountedKeys",
+              "privacy": "private",
+              "default": "new Set<RowKey>()",
+              "description": "Track which keys are currently mounted in the DOM, to honor the contract that mount happens after `updated()` reconciles."
+            },
+            {
+              "kind": "field",
+              "name": "_keyToRow",
+              "privacy": "private",
+              "default": "new Map<RowKey, TableRow>()",
+              "description": "Latest resolved row map: key → row. Filled during render so callbacks can look up rows."
+            },
+            {
+              "kind": "field",
+              "name": "_refCallbacks",
+              "privacy": "private",
+              "default": "new Map<RowKey, (el: Element | undefined) => void>()",
+              "description": "Stable ref callback per row key. One closure per key, reused across renders."
             },
             {
               "kind": "field",
@@ -2657,6 +2742,30 @@
               "privacy": "private",
               "default": "false"
             },
+            {
+              "kind": "method",
+              "name": "_resolveKey",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "RowKey"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "row",
+                  "type": {
+                    "text": "TableRow"
+                  }
+                },
+                {
+                  "name": "index",
+                  "type": {
+                    "text": "number"
+                  }
+                }
+              ]
+            },
             {
               "kind": "method",
               "name": "handleHeaderClick",
@@ -2689,18 +2798,73 @@
                 }
               ]
             },
+            {
+              "kind": "method",
+              "name": "_handleChevronClick",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "event",
+                  "type": {
+                    "text": "Event"
+                  }
+                },
+                {
+                  "name": "key",
+                  "type": {
+                    "text": "RowKey"
+                  }
+                }
+              ],
+              "description": "Chevron button click handler. Stops propagation so it does NOT also fire\nthe row-level `reke-row-click` event, then toggles the row by key."
+            },
+            {
+              "kind": "method",
+              "name": "_handleChevronKeydown",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "event",
+                  "type": {
+                    "text": "KeyboardEvent"
+                  }
+                },
+                {
+                  "name": "key",
+                  "type": {
+                    "text": "RowKey"
+                  }
+                }
+              ],
+              "description": "Chevron keyboard activation. The element is a native `<button>`, so Enter\nalready fires `click` natively. We still handle it here to keep the\nkeyboard contract explicit and testable across environments where the\n`KeyboardEvent` is dispatched programmatically (Vitest browser mode tests\ndispatch raw `keydown`s without the synthesized `click`).\n\nFor Space we MUST call `preventDefault()` so the page does not scroll."
+            },
             {
               "kind": "method",
               "name": "toggleExpand",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
               "parameters": [
                 {
-                  "name": "index",
+                  "name": "target",
                   "type": {
-                    "text": "number"
+                    "text": "number | RowKey"
                   }
                 }
               ],
-              "description": "Toggle expand state for a row at the given index."
+              "description": "Toggle expand state for a row.\nAccepts either a numeric `index` into `rows` or a `RowKey` (the value returned by `getRowKey`).\nWhen `getRowKey` is unset, indices and keys collapse onto `String(index)`."
             },
             {
               "kind": "method",
@@ -2712,13 +2876,13 @@
               },
               "parameters": [
                 {
-                  "name": "index",
+                  "name": "key",
                   "type": {
-                    "text": "number"
+                    "text": "RowKey"
                   }
                 }
               ],
-              "description": "Check whether a row at the given index is currently expanded."
+              "description": "Check whether a row with the given key is currently expanded."
             },
             {
               "kind": "method",
@@ -2748,26 +2912,44 @@
             },
             {
               "kind": "method",
-              "name": "_renderRow",
+              "name": "_getOrCreateHost",
               "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "HTMLElement"
+                }
+              },
               "parameters": [
                 {
-                  "name": "row",
+                  "name": "key",
                   "type": {
-                    "text": "TableRow"
+                    "text": "RowKey"
                   }
-                },
+                }
+              ]
+            },
+            {
+              "kind": "method",
+              "name": "_expandTdRef",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "(el: Element | undefined) => void"
+                }
+              },
+              "parameters": [
                 {
-                  "name": "i",
+                  "name": "key",
                   "type": {
-                    "text": "number"
+                    "text": "RowKey"
                   }
                 }
-              ]
+              ],
+              "description": "Return a STABLE ref callback for a given row key. Lit's `ref()` directive accepts a\ncallback `(el: Element | undefined) => void` directly, so no cast is needed. The callback\nis memoized per key to avoid churning Lit's ref directive on every render."
             },
             {
               "kind": "method",
-              "name": "_renderExpandedElement",
+              "name": "_renderRow",
               "privacy": "private",
               "parameters": [
                 {
@@ -2781,8 +2963,52 @@
                   "type": {
                     "text": "number"
                   }
+                },
+                {
+                  "name": "key",
+                  "type": {
+                    "text": "RowKey"
+                  }
                 }
               ]
+            },
+            {
+              "kind": "field",
+              "name": "_warnedLegacyApi",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "private",
+              "default": "false"
+            },
+            {
+              "kind": "method",
+              "name": "_safeCleanup",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "key",
+                  "type": {
+                    "text": "RowKey"
+                  }
+                }
+              ],
+              "description": "Invoke the cached cleanup for a key, swallowing consumer errors so our own state\nmutation (`expandedRows`, host/cleanup/ref maps) and `emit` stay consistent even if\nthe consumer's cleanup throws. Deletes the cleanup entry after running."
+            },
+            {
+              "kind": "method",
+              "name": "_runAllCleanupsAndClear",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              }
             }
           ],
           "events": [
@@ -2795,7 +3021,7 @@
               "name": "reke-sort"
             },
             {
-              "description": "Fired when a row is expanded or collapsed. Detail: `{ row: TableRow, index: number, expanded: boolean }`.",
+              "description": "Fired when a row is expanded or collapsed. Detail: `{ row: TableRow, index: number, key: RowKey, expanded: boolean }`.",
               "name": "reke-row-expand"
             }
           ],
@@ -2840,6 +3066,24 @@
               "default": "false",
               "fieldName": "borderless"
             },
+            {
+              "name": "expandable",
+              "type": {
+                "text": "boolean"
+              },
+              "default": "false",
+              "description": "Opt-in: when `true`, the table prepends a leading toggle column whose\n`<button>` calls `toggleExpand(key)`, exposes `aria-expanded` reflecting\nthe expand state, `aria-controls` pointing at the expand `<td>` id\n(`reke-table-expand-<key>`), and accepts `Enter` / `Space` activation.\n\nDefaults to `false` so consumers that already wire their own toggles\n(chips, links, custom buttons) are unaffected.",
+              "fieldName": "expandable"
+            },
+            {
+              "name": "expand-on-row-click",
+              "type": {
+                "text": "boolean"
+              },
+              "default": "false",
+              "description": "Opt-in: when `true`, clicking anywhere on a row (outside the chevron, if\npresent) calls `toggleExpand(key)` internally using the row's identity\nkey. The `reke-row-click` event is STILL emitted on every row click so\nconsumers can react in addition to the built-in toggle.\n\nDefault is `false` to preserve non-breaking behavior: existing consumers\nthat wire their own `reke-row-click` → `toggleExpand` handlers are\nunaffected.\n\nA11y note: row clicks are a pointer convenience only. The `<tr>` does NOT\nreceive `role=\"button\"` or `tabindex` (that would be a clickable-row\na11y anti-pattern). For keyboard / screen-reader users, pair this prop\nwith `expandable` so the accessible chevron `<button>` is available.\n\nDouble-wiring caveat: consumers MUST use EITHER `expandOnRowClick` OR\ntheir own `reke-row-click` → `toggleExpand` handler — not both — or the\nrow will toggle twice and net to no change.\n\nChevron interaction: the chevron `<button>` calls `stopPropagation()`, so\nclicking the chevron does NOT trigger the row-click toggle (no double\ntoggle).",
+              "fieldName": "expandOnRowClick"
+            },
             {
               "name": "sort-key",
               "type": {
@@ -2863,7 +3107,7 @@
           },
           "tagName": "reke-table",
           "customElement": true,
-          "summary": "A data table with custom cell rendering, expandable rows, and toolbar/footer slots."
+          "summary": "A data table with custom cell rendering, framework-agnostic expandable rows, and toolbar/footer slots."
         }
       ],
       "exports": [

package/dist/__type-checks__/no-lit-in-public-types.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=no-lit-in-public-types.d.ts.map

package/dist/__type-checks__/no-lit-in-public-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-lit-in-public-types.d.ts","sourceRoot":"","sources":["../../src/__type-checks__/no-lit-in-public-types.ts"],"names":[],"mappings":""}

package/dist/_virtual/_@oxc-project_runtime@0.137.0/helpers/esm/decorate.js

@@ -0,0 +1,9 @@
+//#region \0@oxc-project+runtime@0.137.0/helpers/esm/decorate.js
+function e(e, t, n, r) {
+	var i = arguments.length, a = i < 3 ? t : r === null ? r = Object.getOwnPropertyDescriptor(t, n) : r, o;
+	if (typeof Reflect == "object" && typeof Reflect.decorate == "function") a = Reflect.decorate(e, t, n, r);
+	else for (var s = e.length - 1; s >= 0; s--) (o = e[s]) && (a = (i < 3 ? o(a) : i > 3 ? o(t, n, a) : o(t, n)) || a);
+	return i > 3 && a && Object.defineProperty(t, n, a), a;
+}
+//#endregion
+export { e as __decorate };

package/dist/components/reke-alert/reke-alert.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"reke-alert.d.ts","sourceRoot":"","sources":["../../../src/components/reke-alert/reke-alert.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,WAAW,EAAE,MAAM,8BAA8B,CAAC;AAG3D,MAAM,MAAM,YAAY,GAAG,SAAS,GAAG,OAAO,GAAG,SAAS,GAAG,MAAM,CAAC;AAEpE;;;;;;;;;;;;;;;GAeG;AACH,qBACa,SAAU,SAAQ,WAAW;IACxC,OAAgB,MAAM,4BAAU;IAGhC,OAAO,EAAE,YAAY,CAAU;IAG/B,WAAW,UAAS;IAEpB,OAAO,CAAC,WAAW;IAKV,MAAM;CAyBhB;AAED,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,qBAAqB;QAC7B,YAAY,EAAE,SAAS,CAAC;KACzB;CACF"}
+{"version":3,"file":"reke-alert.d.ts","sourceRoot":"","sources":["../../../src/components/reke-alert/reke-alert.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,WAAW,EAAE,MAAM,8BAA8B,CAAC;AAG3D,MAAM,MAAM,YAAY,GAAG,SAAS,GAAG,OAAO,GAAG,SAAS,GAAG,MAAM,CAAC;AAEpE;;;;;;;;;;;;;;;GAeG;AACH,qBACa,SAAU,SAAQ,WAAW;IACxC,OAAgB,MAAM,4BAAU;IAGhC,OAAO,EAAE,YAAY,CAAU;IAG/B,WAAW,UAAS;IAEpB,OAAO,CAAC,WAAW;IAKV,MAAM;CA2BhB;AAED,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,qBAAqB;QAC7B,YAAY,EAAE,SAAS,CAAC;KACzB;CACF"}