@bamboocss/shared 1.11.1 → 1.11.2

package/dist/uniq-DRfJ796t.mjs

@@ -0,0 +1,310 @@
+//#region src/assert.ts
+const isString = (v) => typeof v === "string";
+const isBoolean = (v) => typeof v === "boolean";
+const isFunction = (v) => typeof v === "function";
+function isObject(value) {
+	return typeof value === "object" && value != null && !Array.isArray(value);
+}
+const isSymbol = (v) => typeof v === "symbol";
+const isObjectOrArray = (obj) => typeof obj === "object" && obj !== null;
+//#endregion
+//#region src/memo.ts
+const 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;
+};
+//#endregion
+//#region src/compact.ts
+function compact(value) {
+	return Object.fromEntries(Object.entries(value ?? {}).filter(([_, value]) => value !== void 0));
+}
+//#endregion
+//#region src/condition.ts
+const isBaseCondition = (v) => v === "base";
+function filterBaseConditions(c) {
+	return c.slice().filter((v) => !isBaseCondition(v));
+}
+//#endregion
+//#region 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);
+}
+//#endregion
+//#region src/important.ts
+const 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;
+}
+function markImportant(obj) {
+	if (typeof obj !== "object" || obj === null) return obj;
+	const result = Array.isArray(obj) ? [] : {};
+	const stack = [{
+		obj,
+		result
+	}];
+	while (stack.length > 0) {
+		const { obj, result } = stack.pop();
+		for (const [key, value] of Object.entries(obj)) if (typeof value === "string" || typeof value === "number") result[key] = `${value} !important`;
+		else if (typeof value === "object" && value !== null) {
+			const next = Array.isArray(value) ? [] : {};
+			result[key] = next;
+			stack.push({
+				obj: value,
+				result: next
+			});
+		} else result[key] = value;
+	}
+	return result;
+}
+//#endregion
+//#region src/merge-props.ts
+const MERGE_OMIT = 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;
+	}, {});
+}
+//#endregion
+//#region src/walk-object.ts
+const 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));
+}
+//#endregion
+//#region 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
+	});
+}
+//#endregion
+//#region src/classname.ts
+const fallbackCondition = {
+	shift: (v) => v,
+	finalize: (v) => v,
+	breakpoints: { keys: [] }
+};
+const sanitize = (value) => typeof value === "string" ? value.replaceAll(/[\n\s]+/g, " ") : value;
+const ENTRY_SEP = "]___[";
+const COND_SEP = "<___>";
+function createCss(context) {
+	const { utility, hash, grouped, 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 result = [...conds.finalize(conditions), formatClassName(className)].join(":");
+		return result;
+	};
+	if (grouped) return memo(({ base, ...styles } = {}) => {
+		const normalizedObject = normalizeStyleObject(Object.assign(styles, base), context);
+		const hashes = [];
+		walkObject(normalizedObject, (value, paths) => {
+			if (value == null) return;
+			const [prop, ...allConditions] = conds.shift(paths);
+			const conditions = filterBaseConditions(allConditions);
+			const parts = [`${prop}${ENTRY_SEP}value:${value}`];
+			if (conditions.length) parts.push(`cond:${conditions.join(COND_SEP)}`);
+			hashes.push(parts.join(ENTRY_SEP));
+		});
+		if (hashes.length === 0) return "";
+		hashes.sort();
+		const groupId = hashes.join("|");
+		return formatClassName(utility.toHash(["grouped", groupId], toHash));
+	});
+	return memo(({ base, ...styles } = {}) => {
+		const normalizedObject = normalizeStyleObject(Object.assign(styles, base), context);
+		const classNames = /* @__PURE__ */ new Set();
+		walkObject(normalizedObject, (value, paths) => {
+			if (value == null) return;
+			const important = isImportant(value);
+			const [prop, ...allConditions] = conds.shift(paths);
+			let className = hashFn(filterBaseConditions(allConditions), utility.transform(prop, withoutImportant(sanitize(value))).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
+	};
+}
+//#endregion
+//#region src/hypenate-property.ts
+const wordRegex = /([A-Z])/g;
+const msRegex = /^ms-/;
+const hypenateProperty = memo((property) => {
+	if (property.startsWith("--")) return property;
+	return property.replace(wordRegex, "-$1").replace(msRegex, "-ms-").toLowerCase();
+});
+//#endregion
+//#region src/is-css-function.ts
+const fnRegExp = new RegExp(`^(${[
+	"min",
+	"max",
+	"clamp",
+	"calc"
+].join("|")})\\(.*\\)`);
+const isCssFunction = (v) => typeof v === "string" && fnRegExp.test(v);
+//#endregion
+//#region src/is-css-unit.ts
+const lengthUnitsPattern = `(?:${"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,%".split(",").join("|")})`;
+const lengthRegExp = new RegExp(`^[+-]?[0-9]*.?[0-9]+(?:[eE][+-]?[0-9]+)?${lengthUnitsPattern}$`);
+const isCssUnit = (v) => typeof v === "string" && lengthRegExp.test(v);
+//#endregion
+//#region src/is-css-var.ts
+const isCssVar = (v) => typeof v === "string" && /^var\(--.+\)$/.test(v);
+//#endregion
+//#region src/pattern-fns.ts
+const patternFns = {
+	map: mapObject,
+	isCssFunction,
+	isCssVar,
+	isCssUnit
+};
+const 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));
+};
+//#endregion
+//#region src/slot.ts
+const 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 recipeParts = (recipe.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);
+};
+const getSlotCompoundVariant = (compoundVariants, slotName) => compoundVariants.filter((compoundVariant) => compoundVariant.css[slotName]).map((compoundVariant) => ({
+	...compoundVariant,
+	css: compoundVariant.css[slotName]
+}));
+//#endregion
+//#region 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));
+}
+//#endregion
+//#region src/uniq.ts
+const 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);
+};
+//#endregion
+export { isObjectOrArray as A, filterBaseConditions as C, isBoolean as D, memo as E, isSymbol as M, isFunction as O, toHash as S, compact as T, mergeProps as _, getPatternStyles as a, withoutImportant as b, isCssUnit as c, createCss as d, createMergeCss as f, walkObject as g, mapObject as h, getSlotRecipes as i, isString as j, isObject as k, isCssFunction as l, toResponsiveObject as m, splitProps as n, patternFns as o, normalizeStyleObject as p, getSlotCompoundVariant as r, isCssVar as s, uniq as t, hypenateProperty as u, isImportant as v, isBaseCondition as w, withoutSpace as x, markImportant as y };

package/dist/uniq-DcY1asOl.d.mts

@@ -0,0 +1,112 @@
+//#region src/assert.d.ts
+declare const isString: (v: any) => v is string;
+declare const isBoolean: (v: any) => v is boolean;
+type AnyFunction = (...args: any[]) => any;
+declare const isFunction: (v: any) => v is AnyFunction;
+declare function isObject(value: any): value is Record<string, any>;
+declare const isSymbol: (v: any) => v is symbol;
+declare const isObjectOrArray: (obj: unknown) => obj is object;
+//#endregion
+//#region src/classname.d.ts
+interface CreateCssContext {
+  hash?: boolean;
+  grouped?: boolean;
+  /**
+   * Partial properties from the Utility class
+   */
+  utility: {
+    prefix: string;
+    hasShorthand: boolean;
+    resolveShorthand: (prop: string) => string;
+    transform: (prop: string, value: any) => {
+      className: string;
+    };
+    toHash: (path: string[], toHash: (str: string) => string) => string;
+  };
+  /**
+   * Partial properties from the Condition class
+   */
+  conditions?: {
+    breakpoints: {
+      keys: string[];
+    };
+    shift: (paths: string[]) => string[];
+    finalize: (paths: string[]) => string[];
+  };
+}
+declare function createCss(context: CreateCssContext): ({
+  base,
+  ...styles
+}?: Record<string, any>) => string;
+interface StyleObject {
+  [key: string]: any;
+}
+declare function createMergeCss(context: CreateCssContext): {
+  mergeCss: (...styles: StyleObject[]) => StyleObject;
+  assignCss: (...styles: StyleObject[]) => any;
+};
+//#endregion
+//#region src/compact.d.ts
+declare function compact<T extends Record<string, any>>(value: T): T;
+//#endregion
+//#region src/condition.d.ts
+declare const isBaseCondition: (v: string) => v is "base";
+declare function filterBaseConditions(c: string[]): string[];
+//#endregion
+//#region src/walk-object.d.ts
+type Predicate<R = any> = (value: any, path: string[]) => R;
+type MappedObject<T, K> = { [Prop in keyof T]: T[Prop] extends Array<any> ? MappedObject<T[Prop][number], K>[] : T[Prop] extends Record<string, unknown> ? MappedObject<T[Prop], K> : K };
+type WalkObjectStopFn = (value: any, path: string[]) => boolean;
+interface WalkObjectOptions {
+  stop?: WalkObjectStopFn;
+  getKey?(prop: string, value: any): string;
+}
+declare function walkObject<T, K>(target: T, predicate: Predicate<K>, options?: WalkObjectOptions): MappedObject<T, ReturnType<Predicate<K>>>;
+declare function mapObject(obj: any, fn: (value: any) => any): any;
+//#endregion
+//#region src/hash.d.ts
+declare function toHash(value: string): string;
+//#endregion
+//#region src/hypenate-property.d.ts
+declare const hypenateProperty: (property: string) => string;
+//#endregion
+//#region src/important.d.ts
+declare function isImportant<T extends string | number | boolean>(value: T): boolean;
+declare function withoutImportant<T extends string | number | boolean>(value: T): string | T;
+declare function withoutSpace<T extends string | number | boolean>(str: T): string | T;
+type Dict$1 = Record<string, unknown>;
+declare function markImportant(obj: Dict$1): {};
+//#endregion
+//#region src/memo.d.ts
+declare const memo: <T extends (...args: any[]) => any>(fn: T) => T;
+//#endregion
+//#region src/merge-props.d.ts
+declare function mergeProps<T extends Record<string, unknown>>(...sources: T[]): T;
+//#endregion
+//#region src/pattern-fns.d.ts
+declare const patternFns: {
+  map: typeof mapObject;
+  isCssFunction: (v: unknown) => boolean;
+  isCssVar: (v: unknown) => boolean;
+  isCssUnit: (v: unknown) => boolean;
+};
+declare const getPatternStyles: (pattern: any, styles: Record<string, any>) => any;
+//#endregion
+//#region src/slot.d.ts
+declare const getSlotRecipes: (recipe?: Record<string, any>) => Record<string, any>;
+declare const getSlotCompoundVariant: <T extends {
+  css: any;
+}>(compoundVariants: T[], slotName: string) => (T & {
+  css: any;
+})[];
+//#endregion
+//#region src/split-props.d.ts
+type Dict = Record<string, unknown>;
+type PredicateFn = (key: string) => boolean;
+type Key = PredicateFn | string[];
+declare function splitProps(props: Dict, ...keys: Key[]): Dict[];
+//#endregion
+//#region src/uniq.d.ts
+declare const uniq: <T>(...items: T[][]) => T[];
+//#endregion
+export { isString as A, CreateCssContext as C, isFunction as D, isBoolean as E, isObject as O, compact as S, createMergeCss as T, WalkObjectStopFn as _, getPatternStyles as a, filterBaseConditions as b, memo as c, withoutImportant as d, withoutSpace as f, WalkObjectOptions as g, MappedObject as h, getSlotRecipes as i, isSymbol as j, isObjectOrArray as k, isImportant as l, toHash as m, splitProps as n, patternFns as o, hypenateProperty as p, getSlotCompoundVariant as r, mergeProps as s, uniq as t, markImportant as u, mapObject as v, createCss as w, isBaseCondition as x, walkObject as y };

package/dist/uniq-i0QQ2OJM.d.cts

@@ -0,0 +1,112 @@
+//#region src/assert.d.ts
+declare const isString: (v: any) => v is string;
+declare const isBoolean: (v: any) => v is boolean;
+type AnyFunction = (...args: any[]) => any;
+declare const isFunction: (v: any) => v is AnyFunction;
+declare function isObject(value: any): value is Record<string, any>;
+declare const isSymbol: (v: any) => v is symbol;
+declare const isObjectOrArray: (obj: unknown) => obj is object;
+//#endregion
+//#region src/classname.d.ts
+interface CreateCssContext {
+  hash?: boolean;
+  grouped?: boolean;
+  /**
+   * Partial properties from the Utility class
+   */
+  utility: {
+    prefix: string;
+    hasShorthand: boolean;
+    resolveShorthand: (prop: string) => string;
+    transform: (prop: string, value: any) => {
+      className: string;
+    };
+    toHash: (path: string[], toHash: (str: string) => string) => string;
+  };
+  /**
+   * Partial properties from the Condition class
+   */
+  conditions?: {
+    breakpoints: {
+      keys: string[];
+    };
+    shift: (paths: string[]) => string[];
+    finalize: (paths: string[]) => string[];
+  };
+}
+declare function createCss(context: CreateCssContext): ({
+  base,
+  ...styles
+}?: Record<string, any>) => string;
+interface StyleObject {
+  [key: string]: any;
+}
+declare function createMergeCss(context: CreateCssContext): {
+  mergeCss: (...styles: StyleObject[]) => StyleObject;
+  assignCss: (...styles: StyleObject[]) => any;
+};
+//#endregion
+//#region src/compact.d.ts
+declare function compact<T extends Record<string, any>>(value: T): T;
+//#endregion
+//#region src/condition.d.ts
+declare const isBaseCondition: (v: string) => v is "base";
+declare function filterBaseConditions(c: string[]): string[];
+//#endregion
+//#region src/walk-object.d.ts
+type Predicate<R = any> = (value: any, path: string[]) => R;
+type MappedObject<T, K> = { [Prop in keyof T]: T[Prop] extends Array<any> ? MappedObject<T[Prop][number], K>[] : T[Prop] extends Record<string, unknown> ? MappedObject<T[Prop], K> : K };
+type WalkObjectStopFn = (value: any, path: string[]) => boolean;
+interface WalkObjectOptions {
+  stop?: WalkObjectStopFn;
+  getKey?(prop: string, value: any): string;
+}
+declare function walkObject<T, K>(target: T, predicate: Predicate<K>, options?: WalkObjectOptions): MappedObject<T, ReturnType<Predicate<K>>>;
+declare function mapObject(obj: any, fn: (value: any) => any): any;
+//#endregion
+//#region src/hash.d.ts
+declare function toHash(value: string): string;
+//#endregion
+//#region src/hypenate-property.d.ts
+declare const hypenateProperty: (property: string) => string;
+//#endregion
+//#region src/important.d.ts
+declare function isImportant<T extends string | number | boolean>(value: T): boolean;
+declare function withoutImportant<T extends string | number | boolean>(value: T): string | T;
+declare function withoutSpace<T extends string | number | boolean>(str: T): string | T;
+type Dict$1 = Record<string, unknown>;
+declare function markImportant(obj: Dict$1): {};
+//#endregion
+//#region src/memo.d.ts
+declare const memo: <T extends (...args: any[]) => any>(fn: T) => T;
+//#endregion
+//#region src/merge-props.d.ts
+declare function mergeProps<T extends Record<string, unknown>>(...sources: T[]): T;
+//#endregion
+//#region src/pattern-fns.d.ts
+declare const patternFns: {
+  map: typeof mapObject;
+  isCssFunction: (v: unknown) => boolean;
+  isCssVar: (v: unknown) => boolean;
+  isCssUnit: (v: unknown) => boolean;
+};
+declare const getPatternStyles: (pattern: any, styles: Record<string, any>) => any;
+//#endregion
+//#region src/slot.d.ts
+declare const getSlotRecipes: (recipe?: Record<string, any>) => Record<string, any>;
+declare const getSlotCompoundVariant: <T extends {
+  css: any;
+}>(compoundVariants: T[], slotName: string) => (T & {
+  css: any;
+})[];
+//#endregion
+//#region src/split-props.d.ts
+type Dict = Record<string, unknown>;
+type PredicateFn = (key: string) => boolean;
+type Key = PredicateFn | string[];
+declare function splitProps(props: Dict, ...keys: Key[]): Dict[];
+//#endregion
+//#region src/uniq.d.ts
+declare const uniq: <T>(...items: T[][]) => T[];
+//#endregion
+export { isString as A, CreateCssContext as C, isFunction as D, isBoolean as E, isObject as O, compact as S, createMergeCss as T, WalkObjectStopFn as _, getPatternStyles as a, filterBaseConditions as b, memo as c, withoutImportant as d, withoutSpace as f, WalkObjectOptions as g, MappedObject as h, getSlotRecipes as i, isSymbol as j, isObjectOrArray as k, isImportant as l, toHash as m, splitProps as n, patternFns as o, hypenateProperty as p, getSlotCompoundVariant as r, mergeProps as s, uniq as t, markImportant as u, mapObject as v, createCss as w, isBaseCondition as x, walkObject as y };