@design-edito/tools 0.3.9 → 0.3.11

package/agnostic/random/random/index.js

@@ -1,7 +1,7 @@
 // src/agnostic/random/random/index.ts
 function random(bound1 = 1, bound2) {
   const min = bound2 === void 0 ? 0 : bound1;
-  const max = bound2 === void 0 ? bound1 : bound2;
+  const max = bound2 ?? bound1;
   if (min === max || min > max) return void 0;
   const range = max - min;
   return Math.random() * range + min;

package/agnostic/sanitization/html/index.js

@@ -27,12 +27,12 @@ function sanitizeElement(element, options = defaultOptions) {
   const normalizedTagName = tagName.toLowerCase().trim();
   const tagIsInForbidden = forbiddenTags.includes("*") || forbiddenTags.includes(normalizedTagName);
   if (tagIsInForbidden) {
-    if (verbose === true) console.warn(tagName, "tag is forbidden");
+    if (verbose) console.warn(tagName, "tag is forbidden");
     return null;
   }
   const tagIsInAllowed = allowedTags.includes("*") || allowedTags.includes(normalizedTagName);
   if (!tagIsInAllowed) {
-    if (verbose === true) console.warn(tagName, "tag is not allowed");
+    if (verbose) console.warn(tagName, "tag is not allowed");
     return null;
   }
   const returnedElement = Window.get().document.createElement(tagName);
@@ -47,20 +47,20 @@ function sanitizeElement(element, options = defaultOptions) {
       if (typeof nameTester === "string" && nameTester !== "*" && attributeName !== nameTester) return false;
       if (typeof nameTester !== "string" && !nameTester.test(attributeName)) return false;
       if (valTesters === void 0) {
-        if (verbose === true) console.warn(attributeName, "attribute on", tagName, "tag is forbidden");
+        if (verbose) console.warn(attributeName, "attribute on", tagName, "tag is forbidden");
         return true;
       }
       if (valTesters.includes("*")) {
-        if (verbose === true) console.warn(attributeName, "attribute on", tagName, "tag is forbidden");
+        if (verbose) console.warn(attributeName, "attribute on", tagName, "tag is forbidden");
         return true;
       }
       return valTesters.some((valTester) => {
         if (typeof valTester === "string" && attributeValue === valTester) {
-          if (verbose === true) console.warn(attributeValue, "value for", attributeName, "attribute on", tagName, "tag is forbidden. Rule:", valTester);
+          if (verbose) console.warn(attributeValue, "value for", attributeName, "attribute on", tagName, "tag is forbidden. Rule:", valTester);
           return true;
         }
         if (typeof valTester !== "string" && valTester.test(attributeValue)) {
-          if (verbose === true) console.warn(attributeValue, "value for", attributeName, "attribute on", tagName, "tag is forbidden. Rule:", valTester);
+          if (verbose) console.warn(attributeValue, "value for", attributeName, "attribute on", tagName, "tag is forbidden. Rule:", valTester);
           return true;
         }
         return false;
@@ -93,7 +93,7 @@ function sanitizeElement(element, options = defaultOptions) {
       });
     });
     if (!isInAllowed) {
-      if (verbose === true) console.warn(...latestNotAllowedReason);
+      if (verbose) console.warn(...latestNotAllowedReason);
       return false;
     }
     return true;

package/agnostic/sanitization/index.d.ts

@@ -1,4 +1,4 @@
 export * as fileName from './file-name/index.js'
-export * as html from './html/index.js'
 export * as path from './path/index.js'
+export * as html from './html/index.js'
 export * as userInput from './user-input/index.js'

package/agnostic/sanitization/index.js

@@ -1,4 +1,4 @@
 export * as fileName from './file-name/index.js'
-export * as html from './html/index.js'
 export * as path from './path/index.js'
+export * as html from './html/index.js'
 export * as userInput from './user-input/index.js'

package/agnostic/sanitization/types.d.ts

@@ -26,12 +26,8 @@ export type SanitizeHtmlOptions = {
     keepComments?: boolean;
     allowedTags?: string[];
     forbiddenTags?: string[];
-    allowedAttributes?: {
-        [tagName: string]: AttributeNameValPair[];
-    };
-    forbiddenAttributes?: {
-        [tagName: string]: AttributeNameValPair[];
-    };
+    allowedAttributes?: Record<string, AttributeNameValPair[]>;
+    forbiddenAttributes?: Record<string, AttributeNameValPair[]>;
     depth?: number;
     verbose?: boolean;
 };

package/agnostic/strings/char-codes/index.d.ts

@@ -43,25 +43,25 @@ export declare function charFromB36CharCode(b36CharCode: B36CharCode): string;
  * @param string - Input string.
  * @returns Array of character codes.
  */
-export declare function toCharCodes(string: string): Array<CharCode>;
+export declare function toCharCodes(string: string): CharCode[];
 /**
  * Converts a string into an array of base-36 encoded character codes.
  * @param string - Input string.
  * @returns Array of base-36 character codes.
  */
-export declare function toB36CharCodes(string: string): Array<B36CharCode>;
+export declare function toB36CharCodes(string: string): B36CharCode[];
 /**
  * Converts an array of Unicode character codes back to a string.
  * @param charCodes - Array of character codes.
  * @returns Reconstructed string.
  */
-export declare function fromCharCodes(charCodes: Array<CharCode>): string;
+export declare function fromCharCodes(charCodes: CharCode[]): string;
 /**
  * Converts an array of base-36 encoded character codes back to a string.
  * @param b36CharCodes - Array of base-36 character codes.
  * @returns Reconstructed string.
  */
-export declare function fromB36CharCodes(b36CharCodes: Array<B36CharCode>): string;
+export declare function fromB36CharCodes(b36CharCodes: B36CharCode[]): string;
 /**
  * Serializes an array of character codes (Unicode or base-36) into a string.
  * @param charCodes - Array of character codes to serialize.
@@ -73,7 +73,7 @@ export declare function serialize(charCodes: Array<CharCode | B36CharCode>): str
  * @param serializedCharCodes - Serialized string.
  * @returns Array of Unicode character codes.
  */
-export declare function deserialize(serializedCharCodes: string): Array<CharCode>;
+export declare function deserialize(serializedCharCodes: string): CharCode[];
 /**
  * Deserializes a string of base-36 character codes and reconstructs the original string.
  * @param serializedCharCodes - Serialized string.

package/agnostic/strings/char-codes/index.js

@@ -35,10 +35,10 @@ function toB36CharCodes(string) {
   return chars.map(charToB36CharCode);
 }
 function fromCharCodes(charCodes) {
-  return charCodes.map(charFromCharCode).map((char) => char === null ? "\0" : char).join("");
+  return charCodes.map(charFromCharCode).map((char) => char ?? "\0").join("");
 }
 function fromB36CharCodes(b36CharCodes) {
-  return b36CharCodes.map(charFromB36CharCode).map((char) => char === null ? "\0" : char).join("");
+  return b36CharCodes.map(charFromB36CharCode).map((char) => char ?? "\0").join("");
 }
 function serialize(charCodes) {
   return charCodes.map((c) => typeof c === "string" ? c : charCodeToB36(c)).join(",");

package/agnostic/strings/index.d.ts

@@ -1,7 +1,7 @@
-export * as charCodes from './char-codes/index.js'
 export * as matches from './matches/index.js'
+export * as normalizeIndent from './normalize-indent/index.js'
+export * as charCodes from './char-codes/index.js'
+export * as parseTable from './parse-table/index.js'
 export * as replaceAll from './replace-all/index.js'
 export * as toAlphanum from './to-alphanum/index.js'
 export * as trim from './trim/index.js'
-export * as normalizeIndent from './normalize-indent/index.js'
-export * as parseTable from './parse-table/index.js'

package/agnostic/strings/index.js

@@ -1,7 +1,7 @@
-export * as charCodes from './char-codes/index.js'
 export * as matches from './matches/index.js'
+export * as normalizeIndent from './normalize-indent/index.js'
+export * as charCodes from './char-codes/index.js'
+export * as parseTable from './parse-table/index.js'
 export * as replaceAll from './replace-all/index.js'
 export * as toAlphanum from './to-alphanum/index.js'
 export * as trim from './trim/index.js'
-export * as normalizeIndent from './normalize-indent/index.js'
-export * as parseTable from './parse-table/index.js'

package/agnostic/strings/matches/index.d.ts

@@ -17,7 +17,7 @@ export declare function matches(input: string, matcher: Matcher): boolean;
  * @param matchers - A matcher or array of matchers.
  * @returns `true` if the input matches at least one matcher, otherwise `false`.
  */
-export declare function matchesSome(input: string, matchers: Matcher | Array<Matcher>): boolean;
+export declare function matchesSome(input: string, matchers: Matcher | Matcher[]): boolean;
 /**
  * Checks whether a string matches every matcher in a list (or a single matcher).
  *
@@ -25,4 +25,4 @@ export declare function matchesSome(input: string, matchers: Matcher | Array<Mat
  * @param matchers - A matcher or array of matchers.
  * @returns `true` if the input matches all matchers, otherwise `false`.
  */
-export declare function matchesEvery(input: string, matchers: Matcher | Array<Matcher>): boolean;
+export declare function matchesEvery(input: string, matchers: Matcher | Matcher[]): boolean;

package/agnostic/time/dates/format-date/index.js

@@ -1,8 +1,6 @@
 // src/agnostic/time/dates/format-date/index.ts
 function formatDate(date, format, locale = "en") {
-  try {
-    new Intl.DateTimeFormat(locale);
-  } catch {
+  if (Intl.DateTimeFormat.supportedLocalesOf(locale).length === 0) {
     locale = "en";
   }
   const day = date.getDate();
@@ -13,23 +11,39 @@ function formatDate(date, format, locale = "en") {
   const minutes = date.getMinutes();
   const seconds = date.getSeconds();
   const isPM = hours >= 12;
-  const shortDateNames = [...Array(7)].map((_, i) => new Intl.DateTimeFormat(locale, { weekday: "short" }).format(new Date(2023, 0, i + 1)));
-  const dateNames = [...Array(7)].map((_, i) => new Intl.DateTimeFormat(locale, { weekday: "long" }).format(new Date(2023, 0, i + 1)));
-  const shortMonthNames = [...Array(12)].map((_, i) => new Intl.DateTimeFormat(locale, { month: "short" }).format(new Date(2023, i, 1)));
-  const monthNames = [...Array(12)].map((_, i) => new Intl.DateTimeFormat(locale, { month: "long" }).format(new Date(2023, i, 1)));
+  const shortDateNames = [...Array(7)].map((_, i) => new Intl.DateTimeFormat(
+    locale,
+    { weekday: "short" }
+  ).format(new Date(2023, 0, i + 1)));
+  const dateNames = [...Array(7)].map((_, i) => new Intl.DateTimeFormat(
+    locale,
+    { weekday: "long" }
+  ).format(new Date(2023, 0, i + 1)));
+  const shortMonthNames = [...Array(12)].map((_, i) => new Intl.DateTimeFormat(
+    locale,
+    { month: "short" }
+  ).format(new Date(2023, i, 1)));
+  const monthNames = [...Array(12)].map((_, i) => new Intl.DateTimeFormat(
+    locale,
+    { month: "long" }
+  ).format(new Date(2023, i, 1)));
   const replacements = {
     "DD": () => String(day).padStart(2, "0"),
     "D": () => String(day),
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
     "dd": () => dateNames[dayOfWeek],
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
     "d": () => shortDateNames[dayOfWeek],
     "MM": () => String(month + 1).padStart(2, "0"),
     "M": () => String(month + 1),
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
     "MMMM": () => monthNames[month],
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
     "MMM": () => shortMonthNames[month],
     "YYYY": () => String(year),
     "YY": () => String(year).slice(-2),
-    "hh": () => String(hours % 12 || 12).padStart(2, "0"),
-    "h": () => String(hours % 12 || 12),
+    "hh": () => String(hours % 12 !== 0 ? hours % 12 : 12).padStart(2, "0"),
+    "h": () => String(hours % 12 !== 0 ? hours % 12 : 12),
     "HH": () => String(hours).padStart(2, "0"),
     "H": () => String(hours),
     "mm": () => String(minutes).padStart(2, "0"),

package/agnostic/time/duration/index.d.ts

@@ -19,21 +19,42 @@ export declare class Duration {
      * @param type - The unit of the duration, either long or short form.
      */
     constructor(value: number, type: DurationType | DurationTypeShort);
-    toMilliseconds: () => number;
-    toMs(): number;
+    toMilliseconds(): number;
+    toMs: () => number;
     toSeconds(): number;
+    toS: () => number;
+    toSec: () => number;
     toMinutes(): number;
+    toM: () => number;
+    toMin: () => number;
     toHours(): number;
+    toH: () => number;
     toDays(): number;
+    toD: () => number;
     toWeeks(): number;
+    toW: () => number;
     toMonths(): number;
+    toMth: () => number;
     toYear(): number;
+    toY: () => number;
+    toYr: () => number;
 }
 export declare function milliseconds(value: number): Duration;
+export declare const ms: typeof milliseconds;
 export declare function seconds(value: number): Duration;
+export declare const s: typeof seconds;
+export declare const sec: typeof seconds;
 export declare function minutes(value: number): Duration;
+export declare const m: typeof minutes;
+export declare const min: typeof minutes;
 export declare function hours(value: number): Duration;
+export declare const h: typeof hours;
 export declare function days(value: number): Duration;
+export declare const d: typeof days;
 export declare function weeks(value: number): Duration;
+export declare const w: typeof weeks;
 export declare function months(value: number): Duration;
+export declare const mth: typeof months;
 export declare function years(value: number): Duration;
+export declare const y: typeof years;
+export declare const yr: typeof years;

package/agnostic/time/duration/index.js

@@ -10,7 +10,6 @@ var Duration = class {
    */
   constructor(value, type) {
     this.toMilliseconds = this.toMilliseconds.bind(this);
-    this.toMs = this.toMs.bind(this);
     this.toSeconds = this.toSeconds.bind(this);
     this.toMinutes = this.toMinutes.bind(this);
     this.toHours = this.toHours.bind(this);
@@ -39,8 +38,8 @@ var Duration = class {
       this.type = "milliseconds";
     }
   }
-  toMilliseconds = this.toMs;
-  toMs() {
+  // [WIP] why only toMs and no other shorthands ?
+  toMilliseconds() {
     if (this.type === "milliseconds") return this.value;
     if (this.type === "seconds") return this.value * 1e3;
     if (this.type === "minutes") return this.value * 1e3 * 60;
@@ -51,60 +50,93 @@ var Duration = class {
     if (this.type === "years") return this.value * 1e3 * 60 * 60 * 24 * 365;
     return this.value;
   }
+  toMs = this.toMilliseconds.bind(this);
   toSeconds() {
     return this.toMs() / 1e3;
   }
+  toS = this.toSeconds.bind(this);
+  toSec = this.toSeconds.bind(this);
   toMinutes() {
     return this.toMs() / (1e3 * 60);
   }
+  toM = this.toMinutes.bind(this);
+  toMin = this.toMinutes.bind(this);
   toHours() {
     return this.toMs() / (1e3 * 60 * 60);
   }
+  toH = this.toHours.bind(this);
   toDays() {
     return this.toMs() / (1e3 * 60 * 60 * 24);
   }
+  toD = this.toDays.bind(this);
   toWeeks() {
     return this.toMs() / (1e3 * 60 * 60 * 24 * 7);
   }
+  toW = this.toWeeks.bind(this);
   toMonths() {
     return this.toMs() / (1e3 * 60 * 60 * 24 * 30);
   }
+  toMth = this.toMonths.bind(this);
   toYear() {
     return this.toMs() / (1e3 * 60 * 60 * 24 * 365);
   }
+  toY = this.toYear.bind(this);
+  toYr = this.toYear.bind(this);
 };
 function milliseconds(value) {
   return new Duration(value, "milliseconds");
 }
+var ms = milliseconds;
 function seconds(value) {
   return new Duration(value, "seconds");
 }
+var s = seconds;
+var sec = seconds;
 function minutes(value) {
   return new Duration(value, "minutes");
 }
+var m = minutes;
+var min = minutes;
 function hours(value) {
   return new Duration(value, "hours");
 }
+var h = hours;
 function days(value) {
   return new Duration(value, "days");
 }
+var d = days;
 function weeks(value) {
   return new Duration(value, "weeks");
 }
+var w = weeks;
 function months(value) {
   return new Duration(value, "months");
 }
+var mth = months;
 function years(value) {
   return new Duration(value, "years");
 }
+var y = years;
+var yr = years;
 export {
   Duration,
+  d,
   days,
+  h,
   hours,
+  m,
   milliseconds,
+  min,
   minutes,
   months,
+  ms,
+  mth,
+  s,
+  sec,
   seconds,
+  w,
   weeks,
-  years
+  y,
+  years,
+  yr
 };

package/agnostic/time/index.d.ts

@@ -1,5 +1,5 @@
 export * as duration from './duration/index.js'
+export * as dates from './dates/index.js'
+export * as wait from './wait/index.js'
 export * as timeout from './timeout/index.js'
 export * as transitions from './transitions/index.js'
-export * as wait from './wait/index.js'
-export * as dates from './dates/index.js'

package/agnostic/time/index.js

@@ -1,5 +1,5 @@
 export * as duration from './duration/index.js'
+export * as dates from './dates/index.js'
+export * as wait from './wait/index.js'
 export * as timeout from './timeout/index.js'
 export * as transitions from './transitions/index.js'
-export * as wait from './wait/index.js'
-export * as dates from './dates/index.js'

package/agnostic/time/timeout/index.js

@@ -1,7 +1,7 @@
 // src/agnostic/time/timeout/index.ts
-function timeout(timeoutMs, callback) {
+async function timeout(timeoutMs, callback) {
   let hasRejected = false;
-  return new Promise(async (resolve, reject) => {
+  return await new Promise(async (resolve, reject) => {
     const rejectTimeout = setTimeout(() => {
       reject(false);
       hasRejected = true;

package/agnostic/time/transitions/index.d.ts

@@ -54,16 +54,16 @@ export type EasingFunction = (progress: number) => number;
  */
 export type EasingDictionary = Record<string, EasingFunction>;
 /**
- * Performs a numeric transition from 0 to `to` over `durationMs` milliseconds.
+ * Performs a numeric transition from 0 to `steps` over `durationMs` milliseconds.
  * Invokes a callback at each step with the eased value and timestamp.
  *
- * @param to - The number of steps or increments for the transition.
+ * @param steps - The number of steps or increments for the transition.
  * @param durationMs - Total duration of the transition in milliseconds.
  * @param callbackOrEase - Either a callback function for each step or a predefined easing name.
  * @param callback - Optional callback if `callbackOrEase` is an easing name.
  * @returns A promise that resolves when the transition is complete.
  */
-export declare function transition(to: number, durationMs: number, callbackOrEase: Ease | Callback, callback?: Callback): Promise<void>;
+export declare function transition(steps: number, durationMs: number, callbackOrEase: Ease | Callback, callback?: Callback): Promise<void>;
 /**
  * Predefined easing functions used internally by transitions.
  */

package/agnostic/time/transitions/index.js

@@ -34,18 +34,18 @@ var Ease = /* @__PURE__ */ ((Ease2) => {
   Ease2["EASE_IN_OUT_BOUNCE"] = "ease-in-out-bounce";
   return Ease2;
 })(Ease || {});
-async function transition(to, durationMs, callbackOrEase, callback) {
+async function transition(steps, durationMs, callbackOrEase, callback) {
   const ease = typeof callbackOrEase === "string" ? callbackOrEase : "linear" /* LINEAR */;
   const easing = easings[ease];
   if (easing === void 0) return;
   const actualCallback = callback ?? (typeof callbackOrEase === "function" ? callbackOrEase : void 0);
   if (actualCallback === void 0) return;
   const start = Date.now();
-  const timeTable = new Array(to).fill(null).map((_, step) => {
-    const progression = (step + 1) / to;
+  const timeTable = new Array(steps).fill(null).map((_, step) => {
+    const progression = (step + 1) / steps;
     const eased = easing(progression);
     const time = start + eased * durationMs;
-    return { time, step: eased * to };
+    return { time, step: eased * steps };
   });
   for (const { time, step } of timeTable) {
     const now = Date.now();

package/agnostic/time/wait/index.d.ts

@@ -2,6 +2,6 @@
  * Returns a promise that resolves after the specified duration in milliseconds.
  *
  * @param durationMs - Time to wait in milliseconds.
- * @returns A promise that resolves to `true` after the delay.
+ * @returns A promise that resolves to `void` after the delay.
  */
-export declare function wait(durationMs: number): Promise<unknown>;
+export declare function wait(durationMs: number): Promise<void>;

package/agnostic/time/wait/index.js

@@ -1,6 +1,6 @@
 // src/agnostic/time/wait/index.ts
 async function wait(durationMs) {
-  return new Promise((resolve) => {
+  await new Promise((resolve) => {
     setTimeout(() => resolve(true), durationMs);
   });
 }

package/components/Disclaimer/index.d.ts

@@ -0,0 +1,45 @@
+import { type ReactNode, type PropsWithChildren, type FunctionComponent } from 'react';
+import type { WithClassName } from '../utils/types.js';
+/**
+ * Props for the Disclaimer component.
+ *
+ * @property content - Content displayed inside the disclaimer panel.
+ * @property togglerContent - Content rendered inside the dismiss toggler.
+ * If not provided, the toggler is not rendered.
+ * @property isOn - Controls the visibility state. When defined, the component
+ * behaves as a controlled component.
+ * @property defaultIsOn - Default visibility state for uncontrolled mode.
+ * @property stateHandlers - Callbacks invoked after state changes.
+ * @property stateHandlers.toggled - Callback invoked after the disclaimer state changes.
+ * @property actionHandlers - Callbacks invoked before actions are committed.
+ * @property actionHandlers.dismissClick - Callback invoked before the disclaimer is dismissed.
+ * @property className - Optional additional class name(s) applied to the root element.
+ * @property children - Additional content rendered below the disclaimer panel.
+ */
+export type Props = PropsWithChildren<WithClassName<{
+    content?: ReactNode;
+    togglerContent?: ReactNode;
+    isOn?: boolean;
+    defaultIsOn?: boolean;
+    stateHandlers?: {
+        toggled?: (isOn: boolean) => void;
+    };
+    actionHandlers?: {
+        dismissClick?: (prevIsOn: boolean) => void;
+    };
+}>>;
+/**
+ * Component that displays a dismissible disclaimer panel.
+ *
+ * Supports both controlled (`isOn` provided) and uncontrolled modes.
+ *
+ * @param props - Component properties.
+ * @see {@link Props}
+ *
+ * @remarks
+ * - In controlled mode, visibility is driven by `isOn` and internal state
+ *   does not toggle automatically.
+ * - In uncontrolled mode, the component manages its own visibility state.
+ * - Applies `on` and `off` modifier classes depending on visibility state.
+ */
+export declare const Disclaimer: FunctionComponent<Props>;

package/components/Disclaimer/index.js

@@ -0,0 +1,70 @@
+// src/components/Disclaimer/index.tsx
+import {
+  useState,
+  useEffect,
+  useRef
+} from "react";
+import { clss } from "../../agnostic/css/clss/index.js";
+import { mergeClassNames } from "../utils/index.js";
+import { disclaimer as publicClassName } from "../public-classnames.js";
+import cssModule from "./styles.module.css";
+import { jsx, jsxs } from "react/jsx-runtime";
+var Disclaimer = ({
+  content,
+  togglerContent,
+  isOn: isOnProp,
+  defaultIsOn: defaultIsOnProp,
+  stateHandlers,
+  actionHandlers,
+  children,
+  className
+}) => {
+  const [internalIsOn, setInternalIsOn] = useState(isOnProp ?? defaultIsOnProp ?? true);
+  const isOn = isOnProp ?? internalIsOn;
+  const pIsOn = useRef(isOn);
+  useEffect(() => {
+    if (pIsOn.current === isOn) return;
+    stateHandlers?.toggled?.(isOn);
+    pIsOn.current = isOn;
+  }, [isOn]);
+  const handleDismissClick = () => {
+    actionHandlers?.dismissClick?.(isOn);
+    if (isOnProp !== void 0) return;
+    setInternalIsOn(false);
+  };
+  const c = clss(publicClassName, { cssModule });
+  const rootClss = mergeClassNames(
+    c(null, {
+      on: isOn,
+      off: !isOn
+    }),
+    className
+  );
+  const panelClss = c("panel");
+  const contentClss = c("content");
+  const btnClss = c("toggler");
+  const sensitiveClss = c("sensitive");
+  return /* @__PURE__ */ jsxs("div", { className: rootClss, children: [
+    /* @__PURE__ */ jsxs("div", { className: panelClss, children: [
+      content !== void 0 && /* @__PURE__ */ jsx(
+        "div",
+        {
+          className: contentClss,
+          children: content
+        }
+      ),
+      togglerContent !== void 0 && /* @__PURE__ */ jsx(
+        "div",
+        {
+          className: btnClss,
+          onClick: handleDismissClick,
+          children: togglerContent
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsx("div", { className: sensitiveClss, children })
+  ] });
+};
+export {
+  Disclaimer
+};

package/components/Drawer/index.d.ts

@@ -0,0 +1,45 @@
+import { type PropsWithChildren, type FunctionComponent, type ReactNode } from 'react';
+import type { WithClassName } from '../utils/types.js';
+/**
+ * Props for the Drawer component.
+ *
+ * @property openerContent - Content rendered inside the opener control.
+ * @property closerContent - Content rendered inside the closer control.
+ * @property initialIsOpened - Initial open state in uncontrolled mode.
+ * Ignored when `isOpened` is provided.
+ * @property isOpened - Controlled open state. When defined, the component
+ * behaves as a controlled component and internal state is ignored.
+ * @property stateHandlers - Callbacks invoked after the state changes
+ * @property stateHandlers.toggled - Callbacks invoked after the isOpened state has changed
+ * @property className - Additional class name(s) applied to the root element.
+ * @property children - Drawer content.
+ */
+export type Props = PropsWithChildren<WithClassName<{
+    openerContent?: ReactNode;
+    closerContent?: ReactNode;
+    initialIsOpened?: boolean;
+    isOpened?: boolean;
+    stateHandlers?: {
+        toggled?: (isOpen: boolean) => void;
+    };
+}>>;
+/**
+ * Drawer component with optional controlled and uncontrolled behavior.
+ *
+ * @remarks
+ * - In controlled mode (`isOpened` defined), visibility is fully driven by the prop.
+ * - In uncontrolled mode, internal state is initialized from `initialIsOpened`.
+ * - The component measures its content using `ResizeObserverComponent`
+ *   and exposes the dimensions:
+ *   - As CSS custom properties:
+ *     --{prefix}-content-height
+ *     --{prefix}-content-height-px
+ *     --{prefix}-content-width
+ *     --{prefix}-content-width-px
+ *   - As `data-content-width` and `data-content-height` attributes.
+ *
+ * CSS modifier classes:
+ * - `opened` when open
+ * - `closed` when closed
+ */
+export declare const Drawer: FunctionComponent<Props>;