daleui 0.0.2 → 0.0.5

package/styled-system/helpers.mjs

@@ -0,0 +1,316 @@
+// src/assert.ts
+function isObject(value) {
+  return typeof value === "object" && value != null && !Array.isArray(value);
+}
+var isObjectOrArray = (obj) => typeof obj === "object" && obj !== null;
+
+// src/compact.ts
+function compact(value) {
+  return Object.fromEntries(Object.entries(value ?? {}).filter(([_, value2]) => value2 !== void 0));
+}
+
+// src/condition.ts
+var isBaseCondition = (v) => v === "base";
+function filterBaseConditions(c) {
+  return c.slice().filter((v) => !isBaseCondition(v));
+}
+
+// src/hash.ts
+function toChar(code) {
+  return String.fromCharCode(code + (code > 25 ? 39 : 97));
+}
+function toName(code) {
+  let name = "";
+  let x;
+  for (x = Math.abs(code); x > 52; x = x / 52 | 0) name = toChar(x % 52) + name;
+  return toChar(x % 52) + name;
+}
+function toPhash(h, x) {
+  let i = x.length;
+  while (i) h = h * 33 ^ x.charCodeAt(--i);
+  return h;
+}
+function toHash(value) {
+  return toName(toPhash(5381, value) >>> 0);
+}
+
+// src/important.ts
+var importantRegex = /\s*!(important)?/i;
+function isImportant(value) {
+  return typeof value === "string" ? importantRegex.test(value) : false;
+}
+function withoutImportant(value) {
+  return typeof value === "string" ? value.replace(importantRegex, "").trim() : value;
+}
+function withoutSpace(str) {
+  return typeof str === "string" ? str.replaceAll(" ", "_") : str;
+}
+
+// src/memo.ts
+var memo = (fn) => {
+  const cache = /* @__PURE__ */ new Map();
+  const get = (...args) => {
+    const key = JSON.stringify(args);
+    if (cache.has(key)) {
+      return cache.get(key);
+    }
+    const result = fn(...args);
+    cache.set(key, result);
+    return result;
+  };
+  return get;
+};
+
+// src/merge-props.ts
+var MERGE_OMIT = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+function mergeProps(...sources) {
+  return sources.reduce((prev, obj) => {
+    if (!obj) return prev;
+    Object.keys(obj).forEach((key) => {
+      if (MERGE_OMIT.has(key)) return;
+      const prevValue = prev[key];
+      const value = obj[key];
+      if (isObject(prevValue) && isObject(value)) {
+        prev[key] = mergeProps(prevValue, value);
+      } else {
+        prev[key] = value;
+      }
+    });
+    return prev;
+  }, {});
+}
+
+// src/walk-object.ts
+var isNotNullish = (element) => element != null;
+function walkObject(target, predicate, options = {}) {
+  const { stop, getKey } = options;
+  function inner(value, path = []) {
+    if (isObjectOrArray(value)) {
+      const result = {};
+      for (const [prop, child] of Object.entries(value)) {
+        const key = getKey?.(prop, child) ?? prop;
+        const childPath = [...path, key];
+        if (stop?.(value, childPath)) {
+          return predicate(value, path);
+        }
+        const next = inner(child, childPath);
+        if (isNotNullish(next)) {
+          result[key] = next;
+        }
+      }
+      return result;
+    }
+    return predicate(value, path);
+  }
+  return inner(target);
+}
+function mapObject(obj, fn) {
+  if (Array.isArray(obj)) return obj.map((value) => fn(value));
+  if (!isObject(obj)) return fn(obj);
+  return walkObject(obj, (value) => fn(value));
+}
+
+// src/normalize-style-object.ts
+function toResponsiveObject(values, breakpoints) {
+  return values.reduce(
+    (acc, current, index) => {
+      const key = breakpoints[index];
+      if (current != null) {
+        acc[key] = current;
+      }
+      return acc;
+    },
+    {}
+  );
+}
+function normalizeStyleObject(styles, context, shorthand = true) {
+  const { utility, conditions } = context;
+  const { hasShorthand, resolveShorthand } = utility;
+  return walkObject(
+    styles,
+    (value) => {
+      return Array.isArray(value) ? toResponsiveObject(value, conditions.breakpoints.keys) : value;
+    },
+    {
+      stop: (value) => Array.isArray(value),
+      getKey: shorthand ? (prop) => hasShorthand ? resolveShorthand(prop) : prop : void 0
+    }
+  );
+}
+
+// src/classname.ts
+var fallbackCondition = {
+  shift: (v) => v,
+  finalize: (v) => v,
+  breakpoints: { keys: [] }
+};
+var sanitize = (value) => typeof value === "string" ? value.replaceAll(/[\n\s]+/g, " ") : value;
+function createCss(context) {
+  const { utility, hash, conditions: conds = fallbackCondition } = context;
+  const formatClassName = (str) => [utility.prefix, str].filter(Boolean).join("-");
+  const hashFn = (conditions, className) => {
+    let result;
+    if (hash) {
+      const baseArray = [...conds.finalize(conditions), className];
+      result = formatClassName(utility.toHash(baseArray, toHash));
+    } else {
+      const baseArray = [...conds.finalize(conditions), formatClassName(className)];
+      result = baseArray.join(":");
+    }
+    return result;
+  };
+  return memo(({ base, ...styles } = {}) => {
+    const styleObject = Object.assign(styles, base);
+    const normalizedObject = normalizeStyleObject(styleObject, context);
+    const classNames = /* @__PURE__ */ new Set();
+    walkObject(normalizedObject, (value, paths) => {
+      if (value == null) return;
+      const important = isImportant(value);
+      const [prop, ...allConditions] = conds.shift(paths);
+      const conditions = filterBaseConditions(allConditions);
+      const transformed = utility.transform(prop, withoutImportant(sanitize(value)));
+      let className = hashFn(conditions, transformed.className);
+      if (important) className = `${className}!`;
+      classNames.add(className);
+    });
+    return Array.from(classNames).join(" ");
+  });
+}
+function compactStyles(...styles) {
+  return styles.flat().filter((style) => isObject(style) && Object.keys(compact(style)).length > 0);
+}
+function createMergeCss(context) {
+  function resolve(styles) {
+    const allStyles = compactStyles(...styles);
+    if (allStyles.length === 1) return allStyles;
+    return allStyles.map((style) => normalizeStyleObject(style, context));
+  }
+  function mergeCss(...styles) {
+    return mergeProps(...resolve(styles));
+  }
+  function assignCss(...styles) {
+    return Object.assign({}, ...resolve(styles));
+  }
+  return { mergeCss: memo(mergeCss), assignCss };
+}
+
+// src/hypenate-property.ts
+var wordRegex = /([A-Z])/g;
+var msRegex = /^ms-/;
+var hypenateProperty = memo((property) => {
+  if (property.startsWith("--")) return property;
+  return property.replace(wordRegex, "-$1").replace(msRegex, "-ms-").toLowerCase();
+});
+
+// src/is-css-function.ts
+var fns = ["min", "max", "clamp", "calc"];
+var fnRegExp = new RegExp(`^(${fns.join("|")})\\(.*\\)`);
+var isCssFunction = (v) => typeof v === "string" && fnRegExp.test(v);
+
+// src/is-css-unit.ts
+var lengthUnits = "cm,mm,Q,in,pc,pt,px,em,ex,ch,rem,lh,rlh,vw,vh,vmin,vmax,vb,vi,svw,svh,lvw,lvh,dvw,dvh,cqw,cqh,cqi,cqb,cqmin,cqmax,%";
+var lengthUnitsPattern = `(?:${lengthUnits.split(",").join("|")})`;
+var lengthRegExp = new RegExp(`^[+-]?[0-9]*.?[0-9]+(?:[eE][+-]?[0-9]+)?${lengthUnitsPattern}$`);
+var isCssUnit = (v) => typeof v === "string" && lengthRegExp.test(v);
+
+// src/is-css-var.ts
+var isCssVar = (v) => typeof v === "string" && /^var\(--.+\)$/.test(v);
+
+// src/pattern-fns.ts
+var patternFns = {
+  map: mapObject,
+  isCssFunction,
+  isCssVar,
+  isCssUnit
+};
+var getPatternStyles = (pattern, styles) => {
+  if (!pattern?.defaultValues) return styles;
+  const defaults = typeof pattern.defaultValues === "function" ? pattern.defaultValues(styles) : pattern.defaultValues;
+  return Object.assign({}, defaults, compact(styles));
+};
+
+// src/slot.ts
+var getSlotRecipes = (recipe = {}) => {
+  const init = (slot) => ({
+    className: [recipe.className, slot].filter(Boolean).join("__"),
+    base: recipe.base?.[slot] ?? {},
+    variants: {},
+    defaultVariants: recipe.defaultVariants ?? {},
+    compoundVariants: recipe.compoundVariants ? getSlotCompoundVariant(recipe.compoundVariants, slot) : []
+  });
+  const slots = recipe.slots ?? [];
+  const recipeParts = slots.map((slot) => [slot, init(slot)]);
+  for (const [variantsKey, variantsSpec] of Object.entries(recipe.variants ?? {})) {
+    for (const [variantKey, variantSpec] of Object.entries(variantsSpec)) {
+      recipeParts.forEach(([slot, slotRecipe]) => {
+        slotRecipe.variants[variantsKey] ??= {};
+        slotRecipe.variants[variantsKey][variantKey] = variantSpec[slot] ?? {};
+      });
+    }
+  }
+  return Object.fromEntries(recipeParts);
+};
+var getSlotCompoundVariant = (compoundVariants, slotName) => compoundVariants.filter((compoundVariant) => compoundVariant.css[slotName]).map((compoundVariant) => ({ ...compoundVariant, css: compoundVariant.css[slotName] }));
+
+// src/split-props.ts
+function splitProps(props, ...keys) {
+  const descriptors = Object.getOwnPropertyDescriptors(props);
+  const dKeys = Object.keys(descriptors);
+  const split = (k) => {
+    const clone = {};
+    for (let i = 0; i < k.length; i++) {
+      const key = k[i];
+      if (descriptors[key]) {
+        Object.defineProperty(clone, key, descriptors[key]);
+        delete descriptors[key];
+      }
+    }
+    return clone;
+  };
+  const fn = (key) => split(Array.isArray(key) ? key : dKeys.filter(key));
+  return keys.map(fn).concat(split(dKeys));
+}
+
+// src/uniq.ts
+var uniq = (...items) => {
+  const set = items.reduce((acc, currItems) => {
+    if (currItems) {
+      currItems.forEach((item) => acc.add(item));
+    }
+    return acc;
+  }, /* @__PURE__ */ new Set([]));
+  return Array.from(set);
+};
+export {
+  compact,
+  createCss,
+  createMergeCss,
+  filterBaseConditions,
+  getPatternStyles,
+  getSlotCompoundVariant,
+  getSlotRecipes,
+  hypenateProperty,
+  isBaseCondition,
+  isObject,
+  mapObject,
+  memo,
+  mergeProps,
+  patternFns,
+  splitProps,
+  toHash,
+  uniq,
+  walkObject,
+  withoutSpace
+};
+
+
+
+
+
+export function __spreadValues(a, b) {
+  return { ...a, ...b }
+}
+
+export function __objRest(source, exclude) {
+  return Object.fromEntries(Object.entries(source).filter(([key]) => !exclude.includes(key)))
+}

package/styled-system/patterns/aspect-ratio.d.ts

@@ -0,0 +1,20 @@
+/* eslint-disable */
+import type { SystemStyleObject, ConditionalValue } from '../types/index';
+import type { Properties } from '../types/csstype';
+import type { SystemProperties } from '../types/style-props';
+import type { DistributiveOmit } from '../types/system-types';
+import type { Tokens } from '../tokens/index';
+
+export interface AspectRatioProperties {
+   ratio?: ConditionalValue<number>
+}
+
+interface AspectRatioStyles extends AspectRatioProperties, DistributiveOmit<SystemStyleObject, keyof AspectRatioProperties | 'aspectRatio'> {}
+
+interface AspectRatioPatternFn {
+  (styles?: AspectRatioStyles): string
+  raw: (styles?: AspectRatioStyles) => SystemStyleObject
+}
+
+
+export declare const aspectRatio: AspectRatioPatternFn;

package/styled-system/patterns/aspect-ratio.mjs

@@ -0,0 +1,38 @@
+import { getPatternStyles, patternFns } from '../helpers.mjs';
+import { css } from '../css/index.mjs';
+
+const aspectRatioConfig = {
+transform(props, { map }) {
+  const { ratio = 4 / 3, ...rest } = props;
+  return {
+    position: "relative",
+    _before: {
+      content: `""`,
+      display: "block",
+      height: "0",
+      paddingBottom: map(ratio, (r) => `${1 / r * 100}%`)
+    },
+    "&>*": {
+      display: "flex",
+      justifyContent: "center",
+      alignItems: "center",
+      overflow: "hidden",
+      position: "absolute",
+      inset: "0",
+      width: "100%",
+      height: "100%"
+    },
+    "&>img, &>video": {
+      objectFit: "cover"
+    },
+    ...rest
+  };
+}}
+
+export const getAspectRatioStyle = (styles = {}) => {
+  const _styles = getPatternStyles(aspectRatioConfig, styles)
+  return aspectRatioConfig.transform(_styles, patternFns)
+}
+
+export const aspectRatio = (styles) => css(getAspectRatioStyle(styles))
+aspectRatio.raw = getAspectRatioStyle

package/styled-system/patterns/bleed.d.ts

@@ -0,0 +1,21 @@
+/* eslint-disable */
+import type { SystemStyleObject, ConditionalValue } from '../types/index';
+import type { Properties } from '../types/csstype';
+import type { SystemProperties } from '../types/style-props';
+import type { DistributiveOmit } from '../types/system-types';
+import type { Tokens } from '../tokens/index';
+
+export interface BleedProperties {
+   inline?: SystemProperties["marginInline"]
+	block?: SystemProperties["marginBlock"]
+}
+
+interface BleedStyles extends BleedProperties, DistributiveOmit<SystemStyleObject, keyof BleedProperties > {}
+
+interface BleedPatternFn {
+  (styles?: BleedStyles): string
+  raw: (styles?: BleedStyles) => SystemStyleObject
+}
+
+
+export declare const bleed: BleedPatternFn;

package/styled-system/patterns/bleed.mjs

@@ -0,0 +1,24 @@
+import { getPatternStyles, patternFns } from '../helpers.mjs';
+import { css } from '../css/index.mjs';
+
+const bleedConfig = {
+transform(props, { map, isCssUnit, isCssVar }) {
+  const { inline, block, ...rest } = props;
+  const valueFn = (v) => isCssUnit(v) || isCssVar(v) ? v : `token(spacing.${v}, ${v})`;
+  return {
+    "--bleed-x": map(inline, valueFn),
+    "--bleed-y": map(block, valueFn),
+    marginInline: "calc(var(--bleed-x, 0) * -1)",
+    marginBlock: "calc(var(--bleed-y, 0) * -1)",
+    ...rest
+  };
+},
+defaultValues:{inline:'0',block:'0'}}
+
+export const getBleedStyle = (styles = {}) => {
+  const _styles = getPatternStyles(bleedConfig, styles)
+  return bleedConfig.transform(_styles, patternFns)
+}
+
+export const bleed = (styles) => css(getBleedStyle(styles))
+bleed.raw = getBleedStyle

package/styled-system/patterns/box.d.ts

@@ -0,0 +1,20 @@
+/* eslint-disable */
+import type { SystemStyleObject, ConditionalValue } from '../types/index';
+import type { Properties } from '../types/csstype';
+import type { SystemProperties } from '../types/style-props';
+import type { DistributiveOmit } from '../types/system-types';
+import type { Tokens } from '../tokens/index';
+
+export interface BoxProperties {
+   
+}
+
+interface BoxStyles extends BoxProperties, DistributiveOmit<SystemStyleObject, keyof BoxProperties > {}
+
+interface BoxPatternFn {
+  (styles?: BoxStyles): string
+  raw: (styles?: BoxStyles) => SystemStyleObject
+}
+
+
+export declare const box: BoxPatternFn;

package/styled-system/patterns/box.mjs

@@ -0,0 +1,15 @@
+import { getPatternStyles, patternFns } from '../helpers.mjs';
+import { css } from '../css/index.mjs';
+
+const boxConfig = {
+transform(props) {
+  return props;
+}}
+
+export const getBoxStyle = (styles = {}) => {
+  const _styles = getPatternStyles(boxConfig, styles)
+  return boxConfig.transform(_styles, patternFns)
+}
+
+export const box = (styles) => css(getBoxStyle(styles))
+box.raw = getBoxStyle

package/styled-system/patterns/center.d.ts

@@ -0,0 +1,20 @@
+/* eslint-disable */
+import type { SystemStyleObject, ConditionalValue } from '../types/index';
+import type { Properties } from '../types/csstype';
+import type { SystemProperties } from '../types/style-props';
+import type { DistributiveOmit } from '../types/system-types';
+import type { Tokens } from '../tokens/index';
+
+export interface CenterProperties {
+   inline?: ConditionalValue<boolean>
+}
+
+interface CenterStyles extends CenterProperties, DistributiveOmit<SystemStyleObject, keyof CenterProperties > {}
+
+interface CenterPatternFn {
+  (styles?: CenterStyles): string
+  raw: (styles?: CenterStyles) => SystemStyleObject
+}
+
+
+export declare const center: CenterPatternFn;

package/styled-system/patterns/center.mjs

@@ -0,0 +1,21 @@
+import { getPatternStyles, patternFns } from '../helpers.mjs';
+import { css } from '../css/index.mjs';
+
+const centerConfig = {
+transform(props) {
+  const { inline, ...rest } = props;
+  return {
+    display: inline ? "inline-flex" : "flex",
+    alignItems: "center",
+    justifyContent: "center",
+    ...rest
+  };
+}}
+
+export const getCenterStyle = (styles = {}) => {
+  const _styles = getPatternStyles(centerConfig, styles)
+  return centerConfig.transform(_styles, patternFns)
+}
+
+export const center = (styles) => css(getCenterStyle(styles))
+center.raw = getCenterStyle

package/styled-system/patterns/circle.d.ts

@@ -0,0 +1,20 @@
+/* eslint-disable */
+import type { SystemStyleObject, ConditionalValue } from '../types/index';
+import type { Properties } from '../types/csstype';
+import type { SystemProperties } from '../types/style-props';
+import type { DistributiveOmit } from '../types/system-types';
+import type { Tokens } from '../tokens/index';
+
+export interface CircleProperties {
+   size?: SystemProperties["width"]
+}
+
+interface CircleStyles extends CircleProperties, DistributiveOmit<SystemStyleObject, keyof CircleProperties > {}
+
+interface CirclePatternFn {
+  (styles?: CircleStyles): string
+  raw: (styles?: CircleStyles) => SystemStyleObject
+}
+
+
+export declare const circle: CirclePatternFn;

package/styled-system/patterns/circle.mjs

@@ -0,0 +1,25 @@
+import { getPatternStyles, patternFns } from '../helpers.mjs';
+import { css } from '../css/index.mjs';
+
+const circleConfig = {
+transform(props) {
+  const { size, ...rest } = props;
+  return {
+    display: "flex",
+    alignItems: "center",
+    justifyContent: "center",
+    flex: "0 0 auto",
+    width: size,
+    height: size,
+    borderRadius: "9999px",
+    ...rest
+  };
+}}
+
+export const getCircleStyle = (styles = {}) => {
+  const _styles = getPatternStyles(circleConfig, styles)
+  return circleConfig.transform(_styles, patternFns)
+}
+
+export const circle = (styles) => css(getCircleStyle(styles))
+circle.raw = getCircleStyle

package/styled-system/patterns/container.d.ts

@@ -0,0 +1,20 @@
+/* eslint-disable */
+import type { SystemStyleObject, ConditionalValue } from '../types/index';
+import type { Properties } from '../types/csstype';
+import type { SystemProperties } from '../types/style-props';
+import type { DistributiveOmit } from '../types/system-types';
+import type { Tokens } from '../tokens/index';
+
+export interface ContainerProperties {
+   
+}
+
+interface ContainerStyles extends ContainerProperties, DistributiveOmit<SystemStyleObject, keyof ContainerProperties > {}
+
+interface ContainerPatternFn {
+  (styles?: ContainerStyles): string
+  raw: (styles?: ContainerStyles) => SystemStyleObject
+}
+
+
+export declare const container: ContainerPatternFn;

package/styled-system/patterns/container.mjs

@@ -0,0 +1,21 @@
+import { getPatternStyles, patternFns } from '../helpers.mjs';
+import { css } from '../css/index.mjs';
+
+const containerConfig = {
+transform(props) {
+  return {
+    position: "relative",
+    maxWidth: "8xl",
+    mx: "auto",
+    px: { base: "4", md: "6", lg: "8" },
+    ...props
+  };
+}}
+
+export const getContainerStyle = (styles = {}) => {
+  const _styles = getPatternStyles(containerConfig, styles)
+  return containerConfig.transform(_styles, patternFns)
+}
+
+export const container = (styles) => css(getContainerStyle(styles))
+container.raw = getContainerStyle

package/styled-system/patterns/cq.d.ts

@@ -0,0 +1,21 @@
+/* eslint-disable */
+import type { SystemStyleObject, ConditionalValue } from '../types/index';
+import type { Properties } from '../types/csstype';
+import type { SystemProperties } from '../types/style-props';
+import type { DistributiveOmit } from '../types/system-types';
+import type { Tokens } from '../tokens/index';
+
+export interface CqProperties {
+   name?: ConditionalValue<Tokens["containerNames"] | Properties["containerName"]>
+	type?: SystemProperties["containerType"]
+}
+
+interface CqStyles extends CqProperties, DistributiveOmit<SystemStyleObject, keyof CqProperties > {}
+
+interface CqPatternFn {
+  (styles?: CqStyles): string
+  raw: (styles?: CqStyles) => SystemStyleObject
+}
+
+
+export declare const cq: CqPatternFn;

package/styled-system/patterns/cq.mjs

@@ -0,0 +1,21 @@
+import { getPatternStyles, patternFns } from '../helpers.mjs';
+import { css } from '../css/index.mjs';
+
+const cqConfig = {
+transform(props) {
+  const { name, type, ...rest } = props;
+  return {
+    containerType: type,
+    containerName: name,
+    ...rest
+  };
+},
+defaultValues:{type:'inline-size'}}
+
+export const getCqStyle = (styles = {}) => {
+  const _styles = getPatternStyles(cqConfig, styles)
+  return cqConfig.transform(_styles, patternFns)
+}
+
+export const cq = (styles) => css(getCqStyle(styles))
+cq.raw = getCqStyle

package/styled-system/patterns/divider.d.ts

@@ -0,0 +1,22 @@
+/* eslint-disable */
+import type { SystemStyleObject, ConditionalValue } from '../types/index';
+import type { Properties } from '../types/csstype';
+import type { SystemProperties } from '../types/style-props';
+import type { DistributiveOmit } from '../types/system-types';
+import type { Tokens } from '../tokens/index';
+
+export interface DividerProperties {
+   orientation?: "horizontal" | "vertical"
+	thickness?: ConditionalValue<Tokens["sizes"] | Properties["borderWidth"]>
+	color?: ConditionalValue<Tokens["colors"] | Properties["borderColor"]>
+}
+
+interface DividerStyles extends DividerProperties, DistributiveOmit<SystemStyleObject, keyof DividerProperties > {}
+
+interface DividerPatternFn {
+  (styles?: DividerStyles): string
+  raw: (styles?: DividerStyles) => SystemStyleObject
+}
+
+
+export declare const divider: DividerPatternFn;