@m3000/market 0.0.1

package/dist/components/primitives/Receipt.d.ts

@@ -0,0 +1,164 @@
+import { Separator } from "./Separator.js";
+import * as React from "react";
+
+//#region src/components/primitives/Receipt.d.ts
+type ReceiptInternalIndexProp = {
+  __receiptIndex?: number;
+};
+interface ReceiptProps extends React.ComponentProps<"div"> {
+  decimals?: number;
+}
+interface ReceiptPriceProps {
+  maxDecimals?: number;
+  abbreviate?: boolean;
+  children: React.ReactNode;
+}
+declare function ReceiptPrice(_props: ReceiptPriceProps): React.ReactElement;
+interface ReceiptHeaderProps extends React.ComponentProps<"div"> {}
+declare function ReceiptHeader({
+  children,
+  className,
+  ...props
+}: ReceiptHeaderProps): React.ReactElement;
+interface ReceiptItemProps extends Omit<React.ComponentProps<"div">, "children">, ReceiptInternalIndexProp {
+  label: string;
+  value: bigint | number | string;
+  decimals?: number;
+  maxDecimals?: number;
+  abbreviate?: boolean;
+  children?: React.ReactNode;
+}
+declare function ReceiptItem({
+  label,
+  value,
+  decimals,
+  maxDecimals,
+  abbreviate,
+  children,
+  className,
+  __receiptIndex: _receiptIndex,
+  ...props
+}: ReceiptItemProps): React.ReactElement;
+interface ReceiptSeparatorProps extends React.ComponentProps<typeof Separator> {}
+declare function ReceiptSeparator({
+  className,
+  ...props
+}: ReceiptSeparatorProps): React.ReactElement;
+interface ReceiptSubtotalProps extends React.ComponentProps<"div">, ReceiptInternalIndexProp {
+  decimals?: number;
+  maxDecimals?: number;
+  abbreviate?: boolean;
+  label?: string;
+  value?: bigint | number | string;
+  children?: React.ReactNode;
+}
+declare function ReceiptSubtotal({
+  label,
+  value,
+  decimals,
+  maxDecimals,
+  abbreviate,
+  children,
+  className,
+  __receiptIndex: _receiptIndex,
+  ...props
+}: ReceiptSubtotalProps): React.ReactElement;
+interface ReceiptDiscountProps extends Omit<React.ComponentProps<"div">, "children">, ReceiptInternalIndexProp {
+  label: string;
+  value: bigint | number | string;
+  decimals?: number;
+  maxDecimals?: number;
+  abbreviate?: boolean;
+  children?: React.ReactNode;
+}
+declare function ReceiptDiscount({
+  label,
+  value,
+  decimals,
+  maxDecimals,
+  abbreviate,
+  children,
+  className,
+  __receiptIndex: _receiptIndex,
+  ...props
+}: ReceiptDiscountProps): React.ReactElement;
+interface ReceiptFeeProps extends Omit<React.ComponentProps<"div">, "children">, ReceiptInternalIndexProp {
+  label: string;
+  value: bigint | number | string;
+  decimals?: number;
+  maxDecimals?: number;
+  abbreviate?: boolean;
+  children?: React.ReactNode;
+}
+declare function ReceiptFee({
+  label,
+  value,
+  decimals,
+  maxDecimals,
+  abbreviate,
+  children,
+  className,
+  __receiptIndex: _receiptIndex,
+  ...props
+}: ReceiptFeeProps): React.ReactElement;
+interface ReceiptTaxProps extends Omit<React.ComponentProps<"div">, "children">, ReceiptInternalIndexProp {
+  label?: string;
+  value?: bigint | number | string;
+  rate?: number;
+  decimals?: number;
+  maxDecimals?: number;
+  abbreviate?: boolean;
+  children?: React.ReactNode;
+}
+declare function ReceiptTax({
+  label,
+  value,
+  rate,
+  decimals,
+  maxDecimals,
+  abbreviate,
+  children,
+  className,
+  __receiptIndex: _receiptIndex,
+  ...props
+}: ReceiptTaxProps): React.ReactElement;
+interface ReceiptTotalProps extends React.ComponentProps<"div">, ReceiptInternalIndexProp {
+  label?: string;
+  value?: bigint | number | string;
+  decimals?: number;
+  maxDecimals?: number;
+  abbreviate?: boolean;
+  children?: React.ReactNode;
+}
+declare function ReceiptTotal({
+  label,
+  value,
+  decimals,
+  maxDecimals,
+  abbreviate,
+  children,
+  className,
+  __receiptIndex: _receiptIndex,
+  ...props
+}: ReceiptTotalProps): React.ReactElement;
+interface ReceiptFooterProps extends React.ComponentProps<"div"> {}
+declare function ReceiptFooter({
+  children,
+  className,
+  ...props
+}: ReceiptFooterProps): React.ReactElement;
+declare const Receipt: {
+  (props: ReceiptProps): React.ReactElement;
+  Price: typeof ReceiptPrice;
+  Header: typeof ReceiptHeader;
+  Item: typeof ReceiptItem;
+  Separator: typeof ReceiptSeparator;
+  Subtotal: typeof ReceiptSubtotal;
+  Discount: typeof ReceiptDiscount;
+  Fee: typeof ReceiptFee;
+  Tax: typeof ReceiptTax;
+  Total: typeof ReceiptTotal;
+  Footer: typeof ReceiptFooter;
+};
+//#endregion
+export { Receipt, ReceiptDiscountProps, ReceiptFeeProps, ReceiptFooterProps, ReceiptHeaderProps, ReceiptItemProps, ReceiptPriceProps, ReceiptProps, ReceiptSeparatorProps, ReceiptSubtotalProps, ReceiptTaxProps, ReceiptTotalProps };

package/dist/components/primitives/Receipt.js

@@ -0,0 +1,344 @@
+"use client";
+
+import { cn } from "../../lib/cn.js";
+import { Price } from "./Price.js";
+import { Separator } from "./Separator.js";
+import * as React from "react";
+import { jsx, jsxs } from "react/jsx-runtime";
+
+//#region src/components/primitives/Receipt.tsx
+function toBigInt(value) {
+	if (typeof value === "bigint") return value;
+	try {
+		return BigInt(value);
+	} catch {
+		return BigInt(0);
+	}
+}
+function scaleValue(value, fromDecimals, toDecimals) {
+	const normalizedValue = toBigInt(value);
+	if (fromDecimals === toDecimals) return normalizedValue;
+	const scale = BigInt(10 ** Math.abs(toDecimals - fromDecimals));
+	return fromDecimals < toDecimals ? normalizedValue * scale : normalizedValue / scale;
+}
+function computeTaxFromRate(subtotal, decimals, rate) {
+	const taxNum = Number(subtotal) / 10 ** decimals * rate;
+	const multiplier = BigInt(10 ** decimals);
+	return BigInt(Math.round(taxNum * Number(multiplier)));
+}
+const ReceiptContext = React.createContext(null);
+function useReceiptContext() {
+	const context = React.useContext(ReceiptContext);
+	if (!context) throw new Error("Receipt components must be used within a Receipt root");
+	return context;
+}
+const ReceiptPriceContext = React.createContext(null);
+function useReceiptPriceDefaults() {
+	return React.useContext(ReceiptPriceContext);
+}
+function isElementOfType(child, component) {
+	return React.isValidElement(child) && child.type === component;
+}
+function getDisplayValue(explicitValue, fallbackValue) {
+	return explicitValue !== void 0 ? toBigInt(explicitValue) : fallbackValue;
+}
+function computeReceiptValues(descriptors, receiptDecimals) {
+	const subtotals = /* @__PURE__ */ new Map();
+	const taxes = /* @__PURE__ */ new Map();
+	const totals = /* @__PURE__ */ new Map();
+	let subtotalAccumulator = BigInt(0);
+	let positiveAccumulator = BigInt(0);
+	let negativeAccumulator = BigInt(0);
+	for (const descriptor of descriptors) switch (descriptor.kind) {
+		case "item": {
+			const scaledValue = scaleValue(descriptor.value ?? 0, descriptor.decimals, receiptDecimals);
+			subtotalAccumulator += scaledValue;
+			positiveAccumulator += scaledValue;
+			break;
+		}
+		case "discount": {
+			const scaledValue = scaleValue(descriptor.value ?? 0, descriptor.decimals, receiptDecimals);
+			negativeAccumulator += scaledValue;
+			break;
+		}
+		case "fee": {
+			const scaledValue = scaleValue(descriptor.value ?? 0, descriptor.decimals, receiptDecimals);
+			positiveAccumulator += scaledValue;
+			break;
+		}
+		case "subtotal":
+			subtotals.set(descriptor.index, subtotalAccumulator);
+			break;
+		case "tax": {
+			const explicitValue = descriptor.value;
+			const computedTax = explicitValue !== void 0 ? scaleValue(explicitValue, descriptor.decimals, receiptDecimals) : descriptor.rate !== void 0 ? computeTaxFromRate(scaleValue(subtotalAccumulator, receiptDecimals, descriptor.decimals), descriptor.decimals, descriptor.rate) : BigInt(0);
+			taxes.set(descriptor.index, scaleValue(computedTax, descriptor.decimals, receiptDecimals));
+			positiveAccumulator += scaleValue(computedTax, descriptor.decimals, receiptDecimals);
+			break;
+		}
+		case "total":
+			totals.set(descriptor.index, positiveAccumulator - negativeAccumulator);
+			break;
+	}
+	return {
+		subtotals,
+		taxes,
+		totals
+	};
+}
+function ReceiptPrice(_props) {
+	return null;
+}
+function ReceiptHeader({ children, className, ...props }) {
+	return /* @__PURE__ */ jsx("div", {
+		className: cn("text-foreground pb-2", className),
+		...props,
+		children
+	});
+}
+function ReceiptItem({ label, value, decimals, maxDecimals, abbreviate, children, className, __receiptIndex: _receiptIndex, ...props }) {
+	const context = useReceiptContext();
+	const defaults = useReceiptPriceDefaults();
+	const itemDecimals = decimals ?? context.decimals;
+	const priceChildren = children ?? defaults?.template;
+	const priceMaxDecimals = maxDecimals ?? defaults?.maxDecimals;
+	const priceAbbreviate = abbreviate ?? defaults?.abbreviate;
+	return /* @__PURE__ */ jsxs("div", {
+		className: cn("flex items-center justify-between gap-4", className),
+		...props,
+		children: [/* @__PURE__ */ jsx("span", {
+			className: "text-muted-foreground",
+			children: label
+		}), /* @__PURE__ */ jsx(Price, {
+			value,
+			decimals: itemDecimals,
+			maxDecimals: priceMaxDecimals,
+			abbreviate: priceAbbreviate,
+			className: "text-foreground",
+			children: priceChildren
+		})]
+	});
+}
+function ReceiptSeparator({ className, ...props }) {
+	return /* @__PURE__ */ jsx(Separator, {
+		className: cn("my-1", className),
+		...props
+	});
+}
+function ReceiptSubtotal({ label = "Subtotal", value, decimals, maxDecimals, abbreviate, children, className, __receiptIndex: _receiptIndex, ...props }) {
+	const context = useReceiptContext();
+	const defaults = useReceiptPriceDefaults();
+	const displayDecimals = decimals ?? context.decimals;
+	const priceChildren = children ?? defaults?.template;
+	const priceMaxDecimals = maxDecimals ?? defaults?.maxDecimals;
+	const priceAbbreviate = abbreviate ?? defaults?.abbreviate;
+	const displayValue = getDisplayValue(value, scaleValue(_receiptIndex !== void 0 ? context.computed.subtotals.get(_receiptIndex) ?? BigInt(0) : BigInt(0), context.decimals, displayDecimals));
+	return /* @__PURE__ */ jsxs("div", {
+		className: cn("flex items-center justify-between gap-4", className),
+		...props,
+		children: [/* @__PURE__ */ jsx("span", {
+			className: "text-muted-foreground",
+			children: label
+		}), /* @__PURE__ */ jsx(Price, {
+			value: displayValue,
+			decimals: displayDecimals,
+			maxDecimals: priceMaxDecimals,
+			abbreviate: priceAbbreviate,
+			className: "text-foreground",
+			children: priceChildren
+		})]
+	});
+}
+function ReceiptDiscount({ label, value, decimals, maxDecimals, abbreviate, children, className, __receiptIndex: _receiptIndex, ...props }) {
+	const context = useReceiptContext();
+	const defaults = useReceiptPriceDefaults();
+	const displayDecimals = decimals ?? context.decimals;
+	const priceChildren = children ?? defaults?.template;
+	const priceMaxDecimals = maxDecimals ?? defaults?.maxDecimals;
+	const priceAbbreviate = abbreviate ?? defaults?.abbreviate;
+	return /* @__PURE__ */ jsxs("div", {
+		className: cn("flex items-center justify-between gap-4", className),
+		...props,
+		children: [/* @__PURE__ */ jsx("span", {
+			className: "text-muted-foreground",
+			children: label
+		}), /* @__PURE__ */ jsxs("span", {
+			className: "text-foreground",
+			children: ["-", /* @__PURE__ */ jsx(Price, {
+				value,
+				decimals: displayDecimals,
+				maxDecimals: priceMaxDecimals,
+				abbreviate: priceAbbreviate,
+				className: "text-foreground",
+				children: priceChildren
+			})]
+		})]
+	});
+}
+function ReceiptFee({ label, value, decimals, maxDecimals, abbreviate, children, className, __receiptIndex: _receiptIndex, ...props }) {
+	const context = useReceiptContext();
+	const defaults = useReceiptPriceDefaults();
+	const displayDecimals = decimals ?? context.decimals;
+	const priceChildren = children ?? defaults?.template;
+	const priceMaxDecimals = maxDecimals ?? defaults?.maxDecimals;
+	const priceAbbreviate = abbreviate ?? defaults?.abbreviate;
+	return /* @__PURE__ */ jsxs("div", {
+		className: cn("flex items-center justify-between gap-4", className),
+		...props,
+		children: [/* @__PURE__ */ jsx("span", {
+			className: "text-muted-foreground",
+			children: label
+		}), /* @__PURE__ */ jsx(Price, {
+			value,
+			decimals: displayDecimals,
+			maxDecimals: priceMaxDecimals,
+			abbreviate: priceAbbreviate,
+			className: "text-foreground",
+			children: priceChildren
+		})]
+	});
+}
+function ReceiptTax({ label = "Tax", value, rate, decimals, maxDecimals, abbreviate, children, className, __receiptIndex: _receiptIndex, ...props }) {
+	const context = useReceiptContext();
+	const defaults = useReceiptPriceDefaults();
+	const displayDecimals = decimals ?? context.decimals;
+	const priceChildren = children ?? defaults?.template;
+	const priceMaxDecimals = maxDecimals ?? defaults?.maxDecimals;
+	const priceAbbreviate = abbreviate ?? defaults?.abbreviate;
+	const displayValue = getDisplayValue(value, scaleValue(_receiptIndex !== void 0 ? context.computed.taxes.get(_receiptIndex) ?? BigInt(0) : BigInt(0), context.decimals, displayDecimals));
+	return /* @__PURE__ */ jsxs("div", {
+		className: cn("flex items-center justify-between gap-4", className),
+		...props,
+		children: [/* @__PURE__ */ jsxs("span", {
+			className: "text-muted-foreground",
+			children: [label, rate !== void 0 && /* @__PURE__ */ jsxs("span", { children: [
+				" (",
+				parseFloat((rate * 100).toPrecision(10)),
+				"%)"
+			] })]
+		}), /* @__PURE__ */ jsx(Price, {
+			value: displayValue,
+			decimals: displayDecimals,
+			maxDecimals: priceMaxDecimals,
+			abbreviate: priceAbbreviate,
+			className: "text-foreground",
+			children: priceChildren
+		})]
+	});
+}
+function ReceiptTotal({ label = "Total", value, decimals, maxDecimals, abbreviate, children, className, __receiptIndex: _receiptIndex, ...props }) {
+	const context = useReceiptContext();
+	const defaults = useReceiptPriceDefaults();
+	const displayDecimals = decimals ?? context.decimals;
+	const priceChildren = children ?? defaults?.template;
+	const priceMaxDecimals = maxDecimals ?? defaults?.maxDecimals;
+	const priceAbbreviate = abbreviate ?? defaults?.abbreviate;
+	const displayValue = getDisplayValue(value, scaleValue(_receiptIndex !== void 0 ? context.computed.totals.get(_receiptIndex) ?? BigInt(0) : BigInt(0), context.decimals, displayDecimals));
+	return /* @__PURE__ */ jsxs("div", {
+		className: cn("text-foreground flex items-center justify-between gap-4 pt-2 font-medium", className),
+		...props,
+		children: [/* @__PURE__ */ jsx("span", { children: label }), /* @__PURE__ */ jsx("span", {
+			className: "text-foreground",
+			children: /* @__PURE__ */ jsx(Price, {
+				value: displayValue,
+				decimals: displayDecimals,
+				maxDecimals: priceMaxDecimals,
+				abbreviate: priceAbbreviate,
+				className: "text-foreground",
+				children: priceChildren
+			})
+		})]
+	});
+}
+function ReceiptFooter({ children, className, ...props }) {
+	return /* @__PURE__ */ jsx("div", {
+		className: cn("pt-2 text-xs leading-[18px] text-muted-foreground", className),
+		...props,
+		children
+	});
+}
+function ReceiptRoot({ children, className, decimals = 6, ...props }) {
+	let priceDefaults = null;
+	const calculationDescriptors = [];
+	const renderedChildren = React.Children.toArray(children).flatMap((child, index) => {
+		if (isElementOfType(child, ReceiptPrice)) {
+			const { children: template, maxDecimals, abbreviate = false } = child.props;
+			priceDefaults = {
+				template,
+				maxDecimals,
+				abbreviate
+			};
+			return [];
+		}
+		if (!React.isValidElement(child)) return [child];
+		if (isElementOfType(child, ReceiptItem)) calculationDescriptors.push({
+			index,
+			kind: "item",
+			value: child.props.value,
+			decimals: child.props.decimals ?? decimals
+		});
+		else if (isElementOfType(child, ReceiptDiscount)) calculationDescriptors.push({
+			index,
+			kind: "discount",
+			value: child.props.value,
+			decimals: child.props.decimals ?? decimals
+		});
+		else if (isElementOfType(child, ReceiptFee)) calculationDescriptors.push({
+			index,
+			kind: "fee",
+			value: child.props.value,
+			decimals: child.props.decimals ?? decimals
+		});
+		else if (isElementOfType(child, ReceiptSubtotal)) calculationDescriptors.push({
+			index,
+			kind: "subtotal",
+			value: child.props.value,
+			decimals: child.props.decimals ?? decimals
+		});
+		else if (isElementOfType(child, ReceiptTax)) calculationDescriptors.push({
+			index,
+			kind: "tax",
+			value: child.props.value,
+			rate: child.props.rate,
+			decimals: child.props.decimals ?? decimals
+		});
+		else if (isElementOfType(child, ReceiptTotal)) calculationDescriptors.push({
+			index,
+			kind: "total",
+			value: child.props.value,
+			decimals: child.props.decimals ?? decimals
+		});
+		else return [child];
+		return [React.cloneElement(child, { __receiptIndex: index })];
+	});
+	const computed = React.useMemo(() => computeReceiptValues(calculationDescriptors, decimals), [decimals]);
+	return /* @__PURE__ */ jsx(ReceiptContext, {
+		value: React.useMemo(() => ({
+			decimals,
+			computed
+		}), [decimals, computed]),
+		children: /* @__PURE__ */ jsx(ReceiptPriceContext, {
+			value: priceDefaults,
+			children: /* @__PURE__ */ jsx("div", {
+				className: cn("flex flex-col gap-2 text-sm leading-[21px] text-foreground", className),
+				...props,
+				children: renderedChildren
+			})
+		})
+	});
+}
+const Receipt = Object.assign(ReceiptRoot, {
+	Price: ReceiptPrice,
+	Header: ReceiptHeader,
+	Item: ReceiptItem,
+	Separator: ReceiptSeparator,
+	Subtotal: ReceiptSubtotal,
+	Discount: ReceiptDiscount,
+	Fee: ReceiptFee,
+	Tax: ReceiptTax,
+	Total: ReceiptTotal,
+	Footer: ReceiptFooter
+});
+
+//#endregion
+export { Receipt };

package/dist/components/primitives/Scale.d.ts

@@ -0,0 +1,67 @@
+import * as React from "react";
+
+//#region src/components/primitives/Scale.d.ts
+type ScaleValue = number | bigint;
+type SnapMode = "up" | "down" | "nearest";
+interface ScaleContextValue<T extends ScaleValue> {
+  domain: [T, T];
+  getTickSize: (value: T) => T;
+  snapMode: SnapMode | false;
+  getValueAtPosition: (position: number) => T;
+}
+interface TickContext<T extends ScaleValue> {
+  /** The position on the scale (0-1) */
+  position: number;
+  /** The calculated value at this position (snapped to tick grid) */
+  value: T;
+}
+declare function useScale<T extends ScaleValue>(): ScaleContextValue<T>;
+interface LinearProps<T extends ScaleValue> {
+  /** Domain tuple: [min, max] */
+  domain: [T, T];
+  /** Function to get tick size at a given value */
+  getTickSize: (value: T) => T;
+  /** How to snap values to the tick grid (default: 'nearest', false to disable) */
+  snapMode?: SnapMode | false;
+  children: React.ReactNode;
+  className?: string;
+}
+declare function Linear<T extends ScaleValue>({
+  domain,
+  getTickSize,
+  snapMode,
+  children,
+  className
+}: LinearProps<T>): React.ReactElement;
+interface TickProps<T extends ScaleValue> {
+  /** Position on the scale (0 = min, 1 = max) */
+  position: number;
+  /** Render function receiving the tick context */
+  children: (context: TickContext<T>) => React.ReactNode;
+  className?: string;
+}
+declare function Tick<T extends ScaleValue>({
+  position,
+  children,
+  className
+}: TickProps<T>): React.ReactElement;
+interface TicksProps<T extends ScaleValue> {
+  /** Number of ticks to generate (evenly spaced from 0 to 1) */
+  count: number;
+  /** Render function for each tick */
+  children: (context: TickContext<T>, index: number) => React.ReactNode;
+  className?: string;
+}
+declare function Ticks<T extends ScaleValue>({
+  count,
+  children,
+  className
+}: TicksProps<T>): React.ReactElement;
+interface ScaleComponent {
+  Linear: typeof Linear;
+  Tick: typeof Tick;
+  Ticks: typeof Ticks;
+}
+declare const Scale: ScaleComponent;
+//#endregion
+export { Scale, type ScaleValue, type SnapMode, TickContext, useScale };

package/dist/components/primitives/Scale.js

@@ -0,0 +1,132 @@
+"use client";
+
+import * as React from "react";
+import { Fragment, jsx } from "react/jsx-runtime";
+
+//#region src/components/primitives/Scale.tsx
+const ScaleContext = React.createContext(null);
+function useScale() {
+	const context = React.useContext(ScaleContext);
+	if (!context) throw new Error("useScale must be used within Scale.Linear");
+	return context;
+}
+/**
+* Type guard to check if a value is bigint
+*/
+function isBigInt(value) {
+	return typeof value === "bigint";
+}
+/**
+* Linearly interpolate between min and max based on position (0-1).
+* Works with both number and bigint.
+*/
+function interpolate(min, max, position) {
+	const clampedPosition = Math.max(0, Math.min(1, position));
+	if (isBigInt(min) && isBigInt(max)) return min + (max - min) * BigInt(Math.round(clampedPosition * 1e6)) / 1000000n;
+	const numMin = min;
+	return numMin + (max - numMin) * clampedPosition;
+}
+/**
+* Snaps a value to the tick grid based on the specified mode.
+* Works with both number and bigint.
+*/
+function snapToTick(value, tickSize, mode, min) {
+	if (isBigInt(value) && isBigInt(tickSize)) {
+		if (tickSize <= 0n) return value;
+		const remainder = value % tickSize;
+		if (remainder === 0n) return value;
+		let snapped;
+		switch (mode) {
+			case "up":
+				snapped = value - remainder + tickSize;
+				break;
+			case "down":
+				snapped = value - remainder;
+				break;
+			case "nearest":
+				snapped = remainder * 2n >= tickSize ? value - remainder + tickSize : value - remainder;
+				break;
+		}
+		if (min !== void 0 && isBigInt(min) && snapped < min) snapped = min;
+		return snapped;
+	}
+	const numValue = value;
+	const numTickSize = tickSize;
+	const numMin = min;
+	if (numTickSize <= 0) return value;
+	const remainder = numValue % numTickSize;
+	if (Math.abs(remainder) < Number.EPSILON) return value;
+	let snapped;
+	switch (mode) {
+		case "up":
+			snapped = numValue - remainder + numTickSize;
+			break;
+		case "down":
+			snapped = numValue - remainder;
+			break;
+		case "nearest":
+			snapped = remainder * 2 >= numTickSize ? numValue - remainder + numTickSize : numValue - remainder;
+			break;
+	}
+	if (numMin !== void 0 && snapped < numMin) snapped = numMin;
+	return snapped;
+}
+function Linear({ domain, getTickSize, snapMode = "nearest", children, className }) {
+	const [min, max] = domain;
+	const getValueAtPosition = React.useCallback((position) => {
+		const rawValue = interpolate(min, max, position);
+		if (snapMode === false) return rawValue;
+		return snapToTick(rawValue, getTickSize(rawValue), snapMode, min);
+	}, [
+		min,
+		max,
+		getTickSize,
+		snapMode
+	]);
+	const contextValue = React.useMemo(() => ({
+		domain,
+		getTickSize,
+		snapMode,
+		getValueAtPosition
+	}), [
+		domain,
+		getTickSize,
+		snapMode,
+		getValueAtPosition
+	]);
+	return /* @__PURE__ */ jsx(ScaleContext.Provider, {
+		value: contextValue,
+		children: /* @__PURE__ */ jsx("div", {
+			className,
+			children
+		})
+	});
+}
+function Tick({ position, children, className }) {
+	const { getValueAtPosition } = useScale();
+	return /* @__PURE__ */ jsx("div", {
+		className,
+		children: children({
+			position,
+			value: React.useMemo(() => getValueAtPosition(position), [getValueAtPosition, position])
+		})
+	});
+}
+function Ticks({ count, children, className }) {
+	return /* @__PURE__ */ jsx(Fragment, { children: React.useMemo(() => {
+		if (count <= 1) return [0];
+		return Array.from({ length: count }, (_, i) => i / (count - 1));
+	}, [count]).map((position, index) => /* @__PURE__ */ jsx(Tick, {
+		position,
+		className,
+		children: (context) => children(context, index)
+	}, position)) });
+}
+const Scale = {
+	Linear,
+	Tick,
+	Ticks
+};
+
+//#endregion
+export { Scale, useScale };