@pindoba/core-carousel 0.0.0-alpha-20260617191010

package/dist/src/snap-math.js

@@ -0,0 +1,81 @@
+//#region src/snap-math.ts
+/**
+* The anchor point of an extent for a given snap alignment:
+* - `start`  → the leading edge,
+* - `center` → the midpoint,
+* - `end`    → the trailing edge.
+*
+* For RTL horizontal carousels the caller passes an `effectiveAlign` with
+* `start`/`end` swapped, so this stays direction-agnostic.
+*/
+function anchorFor(start, end, align) {
+	if (align === "center") return (start + end) / 2;
+	if (align === "end") return end;
+	return start;
+}
+/**
+* Index of the item whose anchor is closest to the viewport's anchor, optionally
+* biased by `bias` px in the drag direction. The bias is what lets a drag-release
+* commit to the next slide at ~30% drag instead of the 50% a strict nearest-snap
+* would impose. Ties resolve to the lower index (first wins). Returns 0 for an
+* empty list.
+*/
+function nearestIndex(items, vp, align, bias = 0) {
+	const anchor = anchorFor(vp.start, vp.end, align) + bias;
+	let bestIdx = 0;
+	let bestDist = Infinity;
+	for (let i = 0; i < items.length; i++) {
+		const iAnchor = anchorFor(items[i].start, items[i].end, align);
+		const d = Math.abs(iAnchor - anchor);
+		if (d < bestDist) {
+			bestDist = d;
+			bestIdx = i;
+		}
+	}
+	return bestIdx;
+}
+/**
+* Clamp / wrap an index into `[0, count)`. Non-loop clamps to the ends; loop
+* wraps (handling negatives via `((i % count) + count) % count`). Returns 0 when
+* `count <= 0`. This unifies the two near-identical clamp formulas that
+* `create-carousel` previously kept in `clamp()` and `scrollToIndex()`.
+*/
+function clampIndex(i, count, loop) {
+	if (count <= 0) return 0;
+	if (loop) return (i % count + count) % count;
+	if (i < 0) return 0;
+	if (i >= count) return count - 1;
+	return i;
+}
+/**
+* Derive the at-start / at-end edge state from the current scroll offset and the
+* maximum scrollable offset (both in px on the main axis; the caller passes
+* `Math.abs(scrollLeft)` for RTL so this stays direction-agnostic). Tolerates
+* ~1px slop. When there's no overflow (`max <= 0`) it reports at-start but NOT
+* at-end, so a next button stays clickable while async layout settles — the
+* first real scroll event corrects it.
+*/
+function edgeState(current, max) {
+	const hasOverflow = max > 0;
+	return {
+		atStart: !hasOverflow || current <= 1,
+		atEnd: hasOverflow && current >= max - 1
+	};
+}
+/**
+* Swap `start` ↔ `end` alignment for RTL horizontal carousels. In RTL the visual
+* "start" of the track is the viewport's right edge, so an item aligned to
+* `start` should anchor on its right edge — achieved by feeding `anchorFor` the
+* swapped value. `center` is unaffected; vertical/LTR callers pass `rtl=false`
+* and get the alignment back unchanged (zero behavior change).
+*/
+function effectiveAlign(align, rtl) {
+	if (!rtl) return align;
+	if (align === "start") return "end";
+	if (align === "end") return "start";
+	return align;
+}
+//#endregion
+export { anchorFor, clampIndex, edgeState, effectiveAlign, nearestIndex };
+
+//# sourceMappingURL=snap-math.js.map

package/dist/src/snap-math.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"snap-math.js","names":[],"sources":["../../src/snap-math.ts"],"sourcesContent":["import type { CarouselAlign } from \"./types.js\";\n\n/**\n * Pure, DOM-free geometry helpers for the carousel engine. Extracted from\n * `create-carousel` so the alignment / wrap / edge math is unit-testable without a\n * layout engine — happy-dom (and any non-browser test env) reports `0` for every\n * `getBoundingClientRect` / `scrollWidth`, which would otherwise strand all of\n * this logic in e2e-only territory. The DOM functions in `create-carousel` read\n * rects, then delegate the actual math here.\n */\n\n/** A 1-D extent on the main scroll axis (left/right or top/bottom, in px). */\nexport interface Extent {\n  start: number;\n  end: number;\n}\n\n/**\n * The anchor point of an extent for a given snap alignment:\n * - `start`  → the leading edge,\n * - `center` → the midpoint,\n * - `end`    → the trailing edge.\n *\n * For RTL horizontal carousels the caller passes an `effectiveAlign` with\n * `start`/`end` swapped, so this stays direction-agnostic.\n */\nexport function anchorFor(\n  start: number,\n  end: number,\n  align: CarouselAlign,\n): number {\n  if (align === \"center\") return (start + end) / 2;\n  if (align === \"end\") return end;\n  return start;\n}\n\n/**\n * Index of the item whose anchor is closest to the viewport's anchor, optionally\n * biased by `bias` px in the drag direction. The bias is what lets a drag-release\n * commit to the next slide at ~30% drag instead of the 50% a strict nearest-snap\n * would impose. Ties resolve to the lower index (first wins). Returns 0 for an\n * empty list.\n */\nexport function nearestIndex(\n  items: ReadonlyArray<Extent>,\n  vp: Extent,\n  align: CarouselAlign,\n  bias = 0,\n): number {\n  const anchor = anchorFor(vp.start, vp.end, align) + bias;\n  let bestIdx = 0;\n  let bestDist = Infinity;\n  for (let i = 0; i < items.length; i++) {\n    const iAnchor = anchorFor(items[i].start, items[i].end, align);\n    const d = Math.abs(iAnchor - anchor);\n    if (d < bestDist) {\n      bestDist = d;\n      bestIdx = i;\n    }\n  }\n  return bestIdx;\n}\n\n/**\n * Clamp / wrap an index into `[0, count)`. Non-loop clamps to the ends; loop\n * wraps (handling negatives via `((i % count) + count) % count`). Returns 0 when\n * `count <= 0`. This unifies the two near-identical clamp formulas that\n * `create-carousel` previously kept in `clamp()` and `scrollToIndex()`.\n */\nexport function clampIndex(i: number, count: number, loop: boolean): number {\n  if (count <= 0) return 0;\n  if (loop) return ((i % count) + count) % count;\n  if (i < 0) return 0;\n  if (i >= count) return count - 1;\n  return i;\n}\n\n/**\n * Derive the at-start / at-end edge state from the current scroll offset and the\n * maximum scrollable offset (both in px on the main axis; the caller passes\n * `Math.abs(scrollLeft)` for RTL so this stays direction-agnostic). Tolerates\n * ~1px slop. When there's no overflow (`max <= 0`) it reports at-start but NOT\n * at-end, so a next button stays clickable while async layout settles — the\n * first real scroll event corrects it.\n */\nexport function edgeState(\n  current: number,\n  max: number,\n): { atStart: boolean; atEnd: boolean } {\n  const hasOverflow = max > 0;\n  const atStart = !hasOverflow || current <= 1;\n  const atEnd = hasOverflow && current >= max - 1;\n  return { atStart, atEnd };\n}\n\n/**\n * Swap `start` ↔ `end` alignment for RTL horizontal carousels. In RTL the visual\n * \"start\" of the track is the viewport's right edge, so an item aligned to\n * `start` should anchor on its right edge — achieved by feeding `anchorFor` the\n * swapped value. `center` is unaffected; vertical/LTR callers pass `rtl=false`\n * and get the alignment back unchanged (zero behavior change).\n */\nexport function effectiveAlign(\n  align: CarouselAlign,\n  rtl: boolean,\n): CarouselAlign {\n  if (!rtl) return align;\n  if (align === \"start\") return \"end\";\n  if (align === \"end\") return \"start\";\n  return align;\n}\n"],"mappings":";;;;;;;;;;AA0BA,SAAgB,UACd,OACA,KACA,OACQ;CACR,IAAI,UAAU,UAAU,QAAQ,QAAQ,OAAO;CAC/C,IAAI,UAAU,OAAO,OAAO;CAC5B,OAAO;AACT;;;;;;;;AASA,SAAgB,aACd,OACA,IACA,OACA,OAAO,GACC;CACR,MAAM,SAAS,UAAU,GAAG,OAAO,GAAG,KAAK,KAAK,IAAI;CACpD,IAAI,UAAU;CACd,IAAI,WAAW;CACf,KAAK,IAAI,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK;EACrC,MAAM,UAAU,UAAU,MAAM,EAAE,CAAC,OAAO,MAAM,EAAE,CAAC,KAAK,KAAK;EAC7D,MAAM,IAAI,KAAK,IAAI,UAAU,MAAM;EACnC,IAAI,IAAI,UAAU;GAChB,WAAW;GACX,UAAU;EACZ;CACF;CACA,OAAO;AACT;;;;;;;AAQA,SAAgB,WAAW,GAAW,OAAe,MAAuB;CAC1E,IAAI,SAAS,GAAG,OAAO;CACvB,IAAI,MAAM,QAAS,IAAI,QAAS,SAAS;CACzC,IAAI,IAAI,GAAG,OAAO;CAClB,IAAI,KAAK,OAAO,OAAO,QAAQ;CAC/B,OAAO;AACT;;;;;;;;;AAUA,SAAgB,UACd,SACA,KACsC;CACtC,MAAM,cAAc,MAAM;CAG1B,OAAO;EAAE,SAFO,CAAC,eAAe,WAAW;EAEzB,OADJ,eAAe,WAAW,MAAM;CACtB;AAC1B;;;;;;;;AASA,SAAgB,eACd,OACA,KACe;CACf,IAAI,CAAC,KAAK,OAAO;CACjB,IAAI,UAAU,SAAS,OAAO;CAC9B,IAAI,UAAU,OAAO,OAAO;CAC5B,OAAO;AACT"}

package/dist/src/types.d.ts

@@ -0,0 +1,313 @@
+import { WritableAtom } from "nanostores";
+import { CarouselSlots, CarouselStyleProps } from "@pindoba/styles-carousel";
+import { SystemStyleObject } from "@pindoba/styled-system/types";
+import { ElementAttributes, ElementAttributes as ElementAttributes$1, PanelFeedback, PanelFeedback as PanelFeedback$1, PanelRadius, PanelRadius as PanelRadius$1 } from "@pindoba/core-panel";
+
+//#region src/types.d.ts
+type CarouselOrientation = NonNullable<CarouselStyleProps["orientation"]>;
+type CarouselSize = NonNullable<CarouselStyleProps["size"]>;
+type CarouselSlidesPerView = NonNullable<CarouselStyleProps["slidesPerView"]>;
+type CarouselAlign = NonNullable<CarouselStyleProps["align"]>;
+type CarouselItemValue = string;
+/**
+ * Metadata for an item rendered via the `items` prop on `<Carousel>`. Body
+ * content is provided framework-idiomatically by the consumer — named slots
+ * in Astro (`<Fragment slot="<value>">`) or named snippets in Svelte
+ * (`{#snippet <value>()}...{/snippet}`).
+ */
+interface CarouselItemData {
+  value: CarouselItemValue;
+  /** Optional label for accessibility and dot indicators (e.g. "Slide 1"). */
+  label?: string;
+  /** Per-item snap alignment override. */
+  align?: CarouselAlign;
+}
+interface CarouselSlotPassThrough<T = ElementAttributes$1> {
+  style?: SystemStyleObject;
+  props?: T;
+}
+interface CarouselPassThrough<RootEl = ElementAttributes$1, ViewportEl = ElementAttributes$1, TrackEl = ElementAttributes$1, ItemEl = ElementAttributes$1, ControlsEl = ElementAttributes$1, PrevButtonEl = ElementAttributes$1, NextButtonEl = ElementAttributes$1, IndicatorsEl = ElementAttributes$1, IndicatorEl = ElementAttributes$1> {
+  root?: CarouselSlotPassThrough<RootEl>;
+  viewport?: CarouselSlotPassThrough<ViewportEl>;
+  track?: CarouselSlotPassThrough<TrackEl>;
+  item?: CarouselSlotPassThrough<ItemEl>;
+  controls?: CarouselSlotPassThrough<ControlsEl>;
+  prevButton?: CarouselSlotPassThrough<PrevButtonEl>;
+  nextButton?: CarouselSlotPassThrough<NextButtonEl>;
+  indicators?: CarouselSlotPassThrough<IndicatorsEl>;
+  indicator?: CarouselSlotPassThrough<IndicatorEl>;
+  /** Visually-hidden ARIA live region announcing the active slide. */
+  liveRegion?: CarouselSlotPassThrough;
+}
+interface CarouselBaseProps<RootEl = ElementAttributes$1, ViewportEl = ElementAttributes$1, TrackEl = ElementAttributes$1, ItemEl = ElementAttributes$1, ControlsEl = ElementAttributes$1, PrevButtonEl = ElementAttributes$1, NextButtonEl = ElementAttributes$1, IndicatorsEl = ElementAttributes$1, IndicatorEl = ElementAttributes$1> {
+  /**
+   * Axis of scrolling. Horizontal flips the scroll-snap axis to x; vertical
+   * flips it to y and bounds the viewport height.
+   * @default "horizontal"
+   * @group Layout
+   */
+  orientation?: CarouselOrientation;
+  /**
+   * Scale for the gap between slides and the size of indicator dots. Cascades
+   * to items via CSS custom properties.
+   * @default "md"
+   * @group Appearance
+   */
+  size?: CarouselSize;
+  /**
+   * Number of slides visible in the viewport. `"auto"` lets each slide size
+   * itself.
+   * @default 1
+   * @group Layout
+   */
+  slidesPerView?: CarouselSlidesPerView;
+  /**
+   * Scroll-snap alignment applied to each slide.
+   * @default "start"
+   * @group Layout
+   */
+  align?: CarouselAlign;
+  /**
+   * Semantic feedback color forwarded via colorPalette. Controls indicator
+   * color and accent surfaces.
+   * @group Appearance
+   */
+  feedback?: PanelFeedback$1;
+  /**
+   * Border radius applied via connectPanel on the root.
+   * @group Appearance
+   */
+  radius?: PanelRadius$1;
+  /**
+   * Render circular Prev/Next buttons over the viewport.
+   * @default false
+   * @group Behavior
+   */
+  controls?: boolean;
+  /**
+   * Render a tablist of dots that reflect the active slide and jump to a slide
+   * when clicked.
+   * @default false
+   * @group Behavior
+   */
+  indicators?: boolean;
+  /**
+   * When true, next/prev wrap past the ends. Controls the button-disabled
+   * state and autoplay wrap behavior.
+   * @default false
+   * @group Behavior
+   */
+  loop?: boolean;
+  /**
+   * When true, slides scrolled off-screen are marked `aria-hidden` + `inert`
+   * so assistive tech and the tab order skip them (APG carousel pattern).
+   * Off by default because `inert` changes focus reachability.
+   * @default false
+   * @group Accessibility
+   */
+  inertOffscreenSlides?: boolean;
+  /**
+   * Auto-advance interval in milliseconds. `false`/`0` disables autoplay.
+   * Pauses on hover, focus-within, tab-hidden, and prefers-reduced-motion:
+   * reduce.
+   * @default false
+   * @group Behavior
+   */
+  autoplay?: number | false;
+  /**
+   * Accessible label for the carousel region. Forwarded to `aria-label` on the
+   * viewport, and used to announce the active slide via a polite live region.
+   * @group Accessibility
+   */
+  label?: string;
+  /**
+   * Data-driven array of slides. Each item needs a unique `value`; optional
+   * `label` and `align` override the root defaults per item. Body content is
+   * provided via named slots (Astro) or named snippets (Svelte) keyed by
+   * `value`. Mutually exclusive with slot composition.
+   * @group Behavior
+   */
+  items?: CarouselItemData[];
+  /**
+   * Per-slot style and HTML-attribute override bag for the carousel's slots.
+   * @group Advanced
+   */
+  passThrough?: CarouselPassThrough<RootEl, ViewportEl, TrackEl, ItemEl, ControlsEl, PrevButtonEl, NextButtonEl, IndicatorsEl, IndicatorEl>;
+}
+interface CarouselItemBaseProps<ItemEl = ElementAttributes$1> {
+  /**
+   * Unique identifier for the slide, used to key named slots/snippets and to
+   * track the active slide.
+   * @group Behavior
+   */
+  value?: CarouselItemValue;
+  /**
+   * Optional label for accessibility and dot indicators (e.g. "Slide 1").
+   * @group Accessibility
+   */
+  label?: string;
+  /**
+   * Per-item snap alignment override for this slide.
+   * @group Layout
+   */
+  align?: CarouselAlign;
+  /**
+   * Per-slot style and HTML-attribute override bag for the item slot.
+   * @group Advanced
+   */
+  passThrough?: {
+    item?: CarouselSlotPassThrough<ItemEl>;
+  };
+}
+interface ConnectCarouselOptions extends Partial<CarouselBaseProps<object, object, object, object, object, object, object, object, object>> {
+  class?: unknown;
+  /**
+   * Active slide index. Drives the indicators' `aria-current` / `data-active`
+   * mirrors. Frameworks pass their reactive index in.
+   * @default 0
+   */
+  currentIndex?: number;
+  /**
+   * Whether the viewport is scrolled to the very start. Drives the prev
+   * button's `disabled` state (prev is disabled when at start and not looping).
+   * @default false
+   */
+  atScrollStart?: boolean;
+  /**
+   * Whether the viewport is scrolled to the very end. Drives the next button's
+   * `disabled` state (next is disabled when at end and not looping).
+   * @default false
+   */
+  atScrollEnd?: boolean;
+  /**
+   * Number of slides — used to compute the number of indicator dots. Falls back
+   * to `items.length` when omitted.
+   */
+  itemCount?: number;
+}
+interface CarouselRootProps {
+  class: string;
+  "data-component": "carousel";
+  "data-orientation": CarouselOrientation;
+  [key: string]: unknown;
+}
+interface CarouselSlotProps {
+  class: string;
+  [key: string]: unknown;
+}
+/**
+ * `<Button>` bag for the prev/next controls. Carries the composed class plus
+ * the literal `<Button>` variant props and reactive `disabled` state. Templates
+ * spread it directly onto `<Button {...api.prevButtonProps}>`.
+ */
+interface CarouselControlButtonProps {
+  class: string;
+  emphasis: "secondary";
+  shape: "circle";
+  size: "sm";
+  type: "button";
+  "aria-label": string;
+  disabled: boolean;
+  [key: string]: unknown;
+}
+/**
+ * `<button>` bag for a single indicator dot. Carries the composed class, static
+ * markers, and reactive active-state mirrors keyed off `currentIndex`.
+ */
+interface CarouselIndicatorProps {
+  class: string;
+  type: "button";
+  role: "tab";
+  "aria-label": string;
+  "aria-current": "true" | "false";
+  "data-active": "true" | "false";
+  "data-carousel-indicator": "";
+  "data-index": string;
+  [key: string]: unknown;
+}
+/** One indicator entry in the `items` array — id + its pre-computed bag. */
+interface CarouselIndicatorItem {
+  id: string;
+  indicatorProps: CarouselIndicatorProps;
+}
+interface CarouselApi {
+  rootProps: CarouselRootProps;
+  viewportWrapperProps: CarouselSlotProps;
+  viewportProps: CarouselSlotProps;
+  trackProps: CarouselSlotProps;
+  controlsProps: CarouselSlotProps;
+  prevButtonProps: CarouselControlButtonProps;
+  nextButtonProps: CarouselControlButtonProps;
+  indicatorsProps: CarouselSlotProps;
+  /** One bag per indicator dot, indexed by id. Empty when no item count. */
+  items: CarouselIndicatorItem[];
+  liveRegionProps: CarouselSlotProps;
+  element: "div";
+}
+interface ConnectCarouselItemOptions extends Partial<CarouselItemBaseProps<object>> {
+  /** Size inherited from root via CSS vars if omitted. */
+  size?: CarouselSize;
+  slidesPerView?: CarouselSlidesPerView;
+  orientation?: CarouselOrientation;
+  class?: unknown;
+}
+interface CarouselItemRootProps {
+  class: string;
+  "data-component": "carousel-item";
+  "data-orientation": CarouselOrientation;
+  [key: string]: unknown;
+}
+interface CarouselItemApi {
+  itemProps: CarouselItemRootProps;
+  element: "div";
+}
+interface CarouselConfig {
+  orientation?: CarouselOrientation;
+  align?: CarouselAlign;
+  loop?: boolean;
+  /** Auto-advance interval in ms. `false` / `0` disables. */
+  autoplay?: number | false;
+  /** Mark off-screen slides `aria-hidden` + `inert` (opt-in). */
+  inertOffscreenSlides?: boolean;
+  slideCount?: number;
+  initialIndex?: number;
+  onActiveIndexChange?: (index: number) => void;
+}
+interface ScrollToIndexOptions {
+  behavior?: ScrollBehavior;
+}
+interface HeadlessCarousel {
+  $activeIndex: WritableAtom<number>;
+  $slideCount: WritableAtom<number>;
+  /** Reactive config — frameworks push prop changes via the `set*` methods. */
+  $orientation: WritableAtom<CarouselOrientation>;
+  $align: WritableAtom<CarouselAlign>;
+  $loop: WritableAtom<boolean>;
+  $autoplayMs: WritableAtom<number>;
+  /** Scroll boundaries — derived from the viewport's scroll position. */
+  $atScrollStart: WritableAtom<boolean>;
+  $atScrollEnd: WritableAtom<boolean>;
+  setActiveIndex: (index: number) => void;
+  setSlideCount: (count: number) => void;
+  setOrientation: (orientation: CarouselOrientation) => void;
+  setAlign: (align: CarouselAlign) => void;
+  setLoop: (loop: boolean) => void;
+  setAutoplay: (autoplay: number | false) => void;
+  next: () => void;
+  prev: () => void;
+  /**
+   * Wires the viewport's `scroll` and `keydown` listeners, autoplay, and
+   * keeps the `[data-carousel-prev]` / `[data-carousel-next]` buttons inside
+   * `root` in sync with the actual scroll boundaries. Returns a cleanup
+   * function. Calling `registerViewport` again unwires the previous one.
+   */
+  registerViewport: (viewport: HTMLElement, root: HTMLElement) => () => void;
+  /** Smoothly scroll the viewport so `index` is aligned per `$align`. */
+  scrollToIndex: (index: number, options?: ScrollToIndexOptions) => void;
+  /** Like `scrollToIndex` but also resets the autoplay timer. */
+  userGoTo: (index: number) => void;
+  destroy: () => void;
+}
+//#endregion
+export { CarouselAlign, CarouselApi, CarouselBaseProps, CarouselConfig, CarouselControlButtonProps, CarouselIndicatorItem, CarouselIndicatorProps, CarouselItemApi, CarouselItemBaseProps, CarouselItemData, CarouselItemRootProps, CarouselItemValue, CarouselOrientation, CarouselPassThrough, CarouselRootProps, CarouselSize, CarouselSlidesPerView, CarouselSlotPassThrough, CarouselSlotProps, type CarouselSlots, ConnectCarouselItemOptions, ConnectCarouselOptions, type ElementAttributes, HeadlessCarousel, type PanelFeedback, type PanelRadius, ScrollToIndexOptions };
+//# sourceMappingURL=types.d.ts.map

package/dist/src/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","names":[],"sources":["../../src/types.ts"],"mappings":"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"}

package/dist/src/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@pindoba/core-carousel",
+  "version": "0.0.0-alpha-20260617191010",
+  "type": "module",
+  "license": "MIT",
+  "sideEffects": false,
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./*": {
+      "types": "./dist/src/*.d.ts",
+      "import": "./dist/src/*.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "nanostores": "^1.3.0",
+    "@pindoba/styles-carousel": "0.0.0-alpha-20260617191010",
+    "@pindoba/styled-system": "0.0.0-alpha-20260617191010",
+    "@pindoba/core-panel": "0.0.0-alpha-20260617191010",
+    "@pindoba/styles-panel": "0.0.0-alpha-20260617191010"
+  },
+  "devDependencies": {
+    "tsdown": "^0.22.2",
+    "typescript": "^6.0.3"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "dev": "tsdown --watch",
+    "clean": "rm -rf dist && rm -rf node_modules && rm -rf .turbo"
+  }
+}