@ariaui/radius 0.1.2 → 0.1.4

package/dist/chunk-3Y6IG3UW.js

@@ -0,0 +1,341 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+
+// src/parse.ts
+function parseRadius(input) {
+  if (typeof input === "number") {
+    return { value: input, unit: "px", original: `${input}px` };
+  }
+  const trimmed = input.trim();
+  if (trimmed.endsWith("rem")) {
+    const value2 = parseFloat(trimmed);
+    if (Number.isNaN(value2)) throw new Error(`Invalid radius value: "${input}"`);
+    return { value: value2, unit: "rem", original: trimmed };
+  }
+  if (trimmed.endsWith("%")) {
+    const value2 = parseFloat(trimmed);
+    if (Number.isNaN(value2)) throw new Error(`Invalid radius value: "${input}"`);
+    return { value: value2, unit: "%", original: trimmed };
+  }
+  const value = parseFloat(trimmed);
+  if (Number.isNaN(value)) throw new Error(`Invalid radius value: "${input}"`);
+  return { value, unit: "px", original: trimmed.endsWith("px") ? trimmed : `${value}px` };
+}
+function parseCorners(input) {
+  const parts = input.trim().split(/\s+/);
+  if (parts.length === 1) {
+    const v = parseRadius(parts[0]);
+    return { topLeft: v, topRight: v, bottomRight: v, bottomLeft: v };
+  }
+  if (parts.length === 2) {
+    const tlbr = parseRadius(parts[0]);
+    const trbl = parseRadius(parts[1]);
+    return { topLeft: tlbr, topRight: trbl, bottomRight: tlbr, bottomLeft: trbl };
+  }
+  if (parts.length === 3) {
+    const tl = parseRadius(parts[0]);
+    const trbl = parseRadius(parts[1]);
+    const br = parseRadius(parts[2]);
+    return { topLeft: tl, topRight: trbl, bottomRight: br, bottomLeft: trbl };
+  }
+  if (parts.length >= 4) {
+    return {
+      topLeft: parseRadius(parts[0]),
+      topRight: parseRadius(parts[1]),
+      bottomRight: parseRadius(parts[2]),
+      bottomLeft: parseRadius(parts[3])
+    };
+  }
+  throw new Error(`Invalid border-radius shorthand: "${input}"`);
+}
+
+// src/scale.ts
+function createLinearScale(base = 0, step = 4, count = 6) {
+  const result = {};
+  for (let i = 0; i < count; i++) {
+    const value = base + step * i;
+    result[String(i)] = parseRadius(value);
+  }
+  return result;
+}
+function createScale(values) {
+  const result = {};
+  for (const [name, value] of Object.entries(values)) {
+    result[name] = parseRadius(value);
+  }
+  return result;
+}
+function scaleBy(scale, factor) {
+  const result = {};
+  for (const [name, rv] of Object.entries(scale)) {
+    const newValue = round(rv.value * factor);
+    result[name] = {
+      value: newValue,
+      unit: rv.unit,
+      original: `${newValue}${rv.unit}`
+    };
+  }
+  return result;
+}
+function clampScale(scale, min, max) {
+  const result = {};
+  for (const [name, rv] of Object.entries(scale)) {
+    const clamped = Math.max(min, Math.min(max, rv.value));
+    result[name] = {
+      value: clamped,
+      unit: rv.unit,
+      original: `${clamped}${rv.unit}`
+    };
+  }
+  return result;
+}
+function sortedLevels(scale) {
+  return Object.keys(scale).sort((a, b) => {
+    return toPx(scale[a]) - toPx(scale[b]);
+  });
+}
+function stepRadius(scale, current, direction) {
+  const ordered = sortedLevels(scale);
+  const idx = ordered.indexOf(current);
+  if (idx === -1) return current;
+  const next = direction === "up" ? idx + 1 : idx - 1;
+  const clamped = Math.max(0, Math.min(ordered.length - 1, next));
+  return ordered[clamped];
+}
+function round(value) {
+  return Math.round(value * 1e3) / 1e3;
+}
+function toPx(rv) {
+  if (rv.unit === "rem") return rv.value * 16;
+  return rv.value;
+}
+
+// src/corners.ts
+function toRadiusValue(input) {
+  if (typeof input === "object" && "value" in input) return input;
+  return parseRadius(input);
+}
+var ZERO = { value: 0, unit: "px", original: "0px" };
+function uniformCorners(radius) {
+  const v = toRadiusValue(radius);
+  return { topLeft: v, topRight: v, bottomRight: v, bottomLeft: v };
+}
+function setCorner(corners, corner, value) {
+  return __spreadProps(__spreadValues({}, corners), { [corner]: toRadiusValue(value) });
+}
+function setTop(corners, value) {
+  const v = toRadiusValue(value);
+  return __spreadProps(__spreadValues({}, corners), { topLeft: v, topRight: v });
+}
+function setBottom(corners, value) {
+  const v = toRadiusValue(value);
+  return __spreadProps(__spreadValues({}, corners), { bottomLeft: v, bottomRight: v });
+}
+function setLeft(corners, value) {
+  const v = toRadiusValue(value);
+  return __spreadProps(__spreadValues({}, corners), { topLeft: v, bottomLeft: v });
+}
+function setRight(corners, value) {
+  const v = toRadiusValue(value);
+  return __spreadProps(__spreadValues({}, corners), { topRight: v, bottomRight: v });
+}
+function roundCorners(radius, ...corners) {
+  const v = toRadiusValue(radius);
+  return {
+    topLeft: corners.includes("topLeft") ? v : ZERO,
+    topRight: corners.includes("topRight") ? v : ZERO,
+    bottomRight: corners.includes("bottomRight") ? v : ZERO,
+    bottomLeft: corners.includes("bottomLeft") ? v : ZERO
+  };
+}
+
+// src/nesting.ts
+function toRadiusValue2(input) {
+  if (typeof input === "object" && "value" in input) return input;
+  return parseRadius(input);
+}
+function innerRadius(outer, gap) {
+  const o = toRadiusValue2(outer);
+  const inner = Math.max(0, o.value - gap);
+  return {
+    value: inner,
+    unit: o.unit,
+    original: `${inner}${o.unit}`
+  };
+}
+function innerCorners(outer, gap) {
+  return {
+    topLeft: innerRadius(outer.topLeft, gap),
+    topRight: innerRadius(outer.topRight, gap),
+    bottomRight: innerRadius(outer.bottomRight, gap),
+    bottomLeft: innerRadius(outer.bottomLeft, gap)
+  };
+}
+function requiredGap(outer, inner) {
+  const o = toRadiusValue2(outer);
+  const i = toRadiusValue2(inner);
+  return Math.max(0, o.value - i.value);
+}
+function nestingPair(outerRadius, gap) {
+  const outer = parseRadius(outerRadius);
+  const inner = innerRadius(outer, gap);
+  return { outer, inner };
+}
+
+// src/responsive.ts
+var BREAKPOINTS = {
+  sm: 640,
+  md: 768,
+  lg: 1024,
+  xl: 1280,
+  "2xl": 1536
+};
+function responsiveRadius(config, breakpoints = BREAKPOINTS) {
+  const defaultEntry = config["default"];
+  if (defaultEntry === void 0) {
+    throw new Error('responsiveRadius: "default" entry is required');
+  }
+  const defaultValue = parseRadius(defaultEntry);
+  const bps = {};
+  for (const [key, value] of Object.entries(config)) {
+    if (key === "default") continue;
+    if (!(key in breakpoints)) {
+      throw new Error(
+        `responsiveRadius: unknown breakpoint "${key}". Available: ${Object.keys(breakpoints).join(", ")}`
+      );
+    }
+    bps[key] = parseRadius(value);
+  }
+  return { default: defaultValue, breakpoints: bps };
+}
+function mobileRadius(value, factor = 0.75) {
+  const scaled = Math.max(0, Math.round(value.value * factor));
+  return {
+    value: scaled,
+    unit: value.unit,
+    original: `${scaled}${value.unit}`
+  };
+}
+function sortedBreakpoints(responsive, breakpoints = BREAKPOINTS) {
+  return Object.entries(responsive.breakpoints).map(
+    ([name, value]) => {
+      var _a;
+      return [name, (_a = breakpoints[name]) != null ? _a : 0, value];
+    }
+  ).sort((a, b) => a[1] - b[1]);
+}
+
+// src/format.ts
+function round2(value, decimals = 4) {
+  const f = Math.pow(10, decimals);
+  return Math.round(value * f) / f;
+}
+function toCSS(value) {
+  return `${value.value}${value.unit}`;
+}
+function toRem(value, base = 16) {
+  if (value.unit === "rem") return `${value.value}rem`;
+  if (value.unit === "%") return value.original;
+  const rem = round2(value.value / base);
+  return `${rem}rem`;
+}
+function toPx2(value, base = 16) {
+  if (value.unit === "px") return `${value.value}px`;
+  if (value.unit === "%") return value.original;
+  const px = round2(value.value * base);
+  return `${px}px`;
+}
+function toCSSShorthand(corners) {
+  const tl = toCSS(corners.topLeft);
+  const tr = toCSS(corners.topRight);
+  const br = toCSS(corners.bottomRight);
+  const bl = toCSS(corners.bottomLeft);
+  if (tl === tr && tr === br && br === bl) return tl;
+  if (tl === br && tr === bl) return `${tl} ${tr}`;
+  if (tr === bl) return `${tl} ${tr} ${br}`;
+  return `${tl} ${tr} ${br} ${bl}`;
+}
+function toCSSProperties(corners) {
+  return {
+    borderTopLeftRadius: toCSS(corners.topLeft),
+    borderTopRightRadius: toCSS(corners.topRight),
+    borderBottomRightRadius: toCSS(corners.bottomRight),
+    borderBottomLeftRadius: toCSS(corners.bottomLeft)
+  };
+}
+function toCSSDeclaration(corners) {
+  return `border-radius: ${toCSSShorthand(corners)};`;
+}
+function toTailwindClass(value) {
+  return `rounded-[${toCSS(value)}]`;
+}
+function toTailwindCorners(corners) {
+  const tl = toCSS(corners.topLeft);
+  const tr = toCSS(corners.topRight);
+  const br = toCSS(corners.bottomRight);
+  const bl = toCSS(corners.bottomLeft);
+  if (tl === tr && tr === br && br === bl) {
+    return `rounded-[${tl}]`;
+  }
+  return [
+    `rounded-tl-[${tl}]`,
+    `rounded-tr-[${tr}]`,
+    `rounded-br-[${br}]`,
+    `rounded-bl-[${bl}]`
+  ].join(" ");
+}
+function toCSSVar(level) {
+  return `var(--radius-${level})`;
+}
+
+export {
+  parseRadius,
+  parseCorners,
+  createLinearScale,
+  createScale,
+  scaleBy,
+  clampScale,
+  sortedLevels,
+  stepRadius,
+  uniformCorners,
+  setCorner,
+  setTop,
+  setBottom,
+  setLeft,
+  setRight,
+  roundCorners,
+  innerRadius,
+  innerCorners,
+  requiredGap,
+  nestingPair,
+  BREAKPOINTS,
+  responsiveRadius,
+  mobileRadius,
+  sortedBreakpoints,
+  toCSS,
+  toRem,
+  toPx2 as toPx,
+  toCSSShorthand,
+  toCSSProperties,
+  toCSSDeclaration,
+  toTailwindClass,
+  toTailwindCorners,
+  toCSSVar
+};