@plitzi/plitzi-ui 1.6.2

package/dist/components/CodeMirror/CodeMirror.styles.js

@@ -0,0 +1,80 @@
+import e from "../../helpers/cvaWrapper.js";
+var t = {
+	input: e("h-full w-full grow basis-0 overflow-auto", {
+		variants: {
+			intent: {
+				primary: "",
+				custom: ""
+			},
+			disabled: {
+				true: "cursor-not-allowed",
+				false: ""
+			},
+			error: {
+				true: "",
+				false: ""
+			},
+			size: {
+				md: "",
+				sm: "text-sm",
+				xs: "text-xs",
+				custom: ""
+			},
+			rounded: {
+				true: "",
+				false: ""
+			}
+		},
+		compoundVariants: [
+			{
+				rounded: !0,
+				size: "md",
+				className: "rounded-lg"
+			},
+			{
+				rounded: !0,
+				size: "sm",
+				className: "rounded"
+			},
+			{
+				rounded: !0,
+				size: "xs",
+				className: "rounded-sm"
+			}
+		],
+		defaultVariants: {
+			intent: "primary",
+			size: "md",
+			disabled: !1,
+			error: !1
+		}
+	}),
+	iconFloatingContainer: e("", {
+		variants: {
+			error: {
+				true: "items-start!",
+				false: ""
+			},
+			size: {
+				md: "py-1.5",
+				sm: "py-1",
+				xs: "py-0.5"
+			}
+		},
+		compoundVariants: [],
+		defaultVariants: {
+			size: "md",
+			error: !1
+		}
+	}),
+	inputContainer: e("border-none p-0 h-full w-full", {
+		variants: { error: {
+			true: "items-start!",
+			false: ""
+		} },
+		compoundVariants: [],
+		defaultVariants: { error: !1 }
+	})
+};
+//#endregion
+export { t as default };

package/dist/components/CodeMirror/helpers/BasicSetup.d.ts

@@ -0,0 +1,41 @@
+export type BasicSetupOptions = {
+    closeBracketsKeymap?: boolean;
+    defaultKeymap?: boolean;
+    searchKeymap?: boolean;
+    historyKeymap?: boolean;
+    foldKeymap?: boolean;
+    completionKeymap?: boolean;
+    lintKeymap?: boolean;
+    lineNumbers?: boolean;
+    highlightActiveLineGutter?: boolean;
+    highlightSpecialChars?: boolean;
+    history?: boolean;
+    foldGutter?: boolean;
+    drawSelection?: boolean;
+    dropCursor?: boolean;
+    allowMultipleSelections?: boolean;
+    indentOnInput?: boolean;
+    syntaxHighlighting?: boolean;
+    bracketMatching?: boolean;
+    closeBrackets?: boolean;
+    autocompletion?: boolean;
+    rectangularSelection?: boolean;
+    crosshairCursor?: boolean;
+    highlightActiveLine?: boolean;
+    highlightSelectionMatches?: boolean;
+    tabSize?: number;
+};
+export declare const basicSetup: (options?: BasicSetupOptions) => ({
+    extension: import('@codemirror/state').Extension;
+} | readonly import('@codemirror/state').Extension[])[];
+export type MinimalSetupOptions = {
+    defaultKeymap?: boolean;
+    historyKeymap?: boolean;
+    highlightSpecialChars?: boolean;
+    history?: boolean;
+    drawSelection?: boolean;
+    syntaxHighlighting?: boolean;
+};
+export declare const minimalSetup: (options?: MinimalSetupOptions) => ({
+    extension: import('@codemirror/state').Extension;
+} | readonly import('@codemirror/state').Extension[])[];

package/dist/components/CodeMirror/helpers/BasicSetup.js

@@ -0,0 +1,16 @@
+import { autocompletion as e, closeBrackets as t, closeBracketsKeymap as n, completionKeymap as r } from "@codemirror/autocomplete";
+import { defaultKeymap as i, history as a, historyKeymap as o } from "@codemirror/commands";
+import { EditorState as s } from "@codemirror/state";
+import { crosshairCursor as c, drawSelection as l, dropCursor as u, highlightActiveLine as d, highlightActiveLineGutter as f, highlightSpecialChars as p, keymap as m, lineNumbers as h, rectangularSelection as g } from "@codemirror/view";
+import { bracketMatching as _, defaultHighlightStyle as v, foldGutter as y, foldKeymap as b, indentOnInput as x, indentUnit as S, syntaxHighlighting as C } from "@codemirror/language";
+import { lintKeymap as w } from "@codemirror/lint";
+import { highlightSelectionMatches as T, searchKeymap as E } from "@codemirror/search";
+//#region src/components/CodeMirror/helpers/BasicSetup.ts
+var D = (D = {}) => {
+	let O = [];
+	D.closeBracketsKeymap !== !1 && (O = O.concat(n)), D.defaultKeymap !== !1 && (O = O.concat(i)), D.searchKeymap !== !1 && (O = O.concat(E)), D.historyKeymap !== !1 && (O = O.concat(o)), D.foldKeymap !== !1 && (O = O.concat(b)), D.completionKeymap !== !1 && (O = O.concat(r)), D.lintKeymap !== !1 && (O = O.concat(w));
+	let k = [];
+	return D.lineNumbers !== !1 && k.push(h()), D.highlightActiveLineGutter !== !1 && k.push(f()), D.highlightSpecialChars !== !1 && k.push(p()), D.history !== !1 && k.push(a()), D.foldGutter !== !1 && k.push(y()), D.drawSelection !== !1 && k.push(l()), D.dropCursor !== !1 && k.push(u()), D.allowMultipleSelections !== !1 && k.push(s.allowMultipleSelections.of(!0)), D.indentOnInput !== !1 && k.push(x()), D.syntaxHighlighting !== !1 && k.push(C(v, { fallback: !0 })), D.bracketMatching !== !1 && k.push(_()), D.closeBrackets !== !1 && k.push(t()), D.autocompletion !== !1 && k.push(e()), D.rectangularSelection !== !1 && k.push(g()), D.crosshairCursor !== !1 && k.push(c()), D.highlightActiveLine !== !1 && k.push(d()), D.highlightSelectionMatches !== !1 && k.push(T()), D.tabSize && typeof D.tabSize == "number" && k.push(S.of(" ".repeat(D.tabSize))), k.concat([m.of(O.flat())]).filter(Boolean);
+};
+//#endregion
+export { D as basicSetup };

package/dist/components/CodeMirror/hooks/useCodeMirror.d.ts

@@ -0,0 +1,25 @@
+import { EditorView, ViewUpdate } from '@codemirror/view';
+import { BasicSetupOptions } from '../helpers/BasicSetup';
+import { Extension } from '@codemirror/state';
+import { RefObject } from 'react';
+export type StyleSpec = {
+    [propOrSelector: string]: string | number | StyleSpec | null;
+};
+export type UseCodeMirrorProps = {
+    extensions: Extension[];
+    theme: 'light' | 'dark' | 'none';
+    ref?: RefObject<HTMLElement>;
+    editable?: boolean;
+    multiline?: boolean;
+    readOnly?: boolean;
+    placeholder?: string;
+    style?: StyleSpec;
+    basicSetup?: BasicSetupOptions | boolean;
+    value?: string;
+    onChange?: (value: string, viewUpdate?: ViewUpdate) => void;
+};
+declare const useCodeMirror: ({ extensions, theme, style, editable, multiline, readOnly, basicSetup: defaultBasicSetup, placeholder: placeholderString, value, ref, onChange }: UseCodeMirrorProps) => {
+    editorRef: (node?: HTMLDivElement | null) => void;
+    view: EditorView | undefined;
+};
+export default useCodeMirror;

package/dist/components/CodeMirror/hooks/useCodeMirror.js

@@ -0,0 +1,76 @@
+import { basicSetup as e } from "../helpers/BasicSetup.js";
+import { useCallback as t, useEffect as n, useMemo as r, useRef as i, useState as a } from "react";
+import { EditorState as o, StateEffect as s } from "@codemirror/state";
+import { EditorView as c, placeholder as l } from "@codemirror/view";
+import { oneDark as u } from "@codemirror/theme-one-dark";
+//#region src/components/CodeMirror/hooks/useCodeMirror.ts
+var d = ({ extensions: d = [], theme: f = "light", style: p = void 0, editable: m = !0, multiline: h = !0, readOnly: g = !1, basicSetup: _ = !0, placeholder: v = "", value: y = "", ref: b, onChange: x }) => {
+	let [S, C] = a(null), [w, T] = a(void 0), E = i(!1), D = t((e) => {
+		e && (b && typeof b == "object" && (b.current = e), C(e));
+	}, [b]), O = r(() => {
+		let t = [...d, c.theme({ "&": p ?? {} })];
+		switch (f) {
+			case "light":
+				t.push(c.theme({ "&": {
+					backgroundColor: "#fff",
+					color: "inherit"
+				} }, { dark: !1 }));
+				break;
+			case "dark":
+				t.push(u);
+				break;
+			case "none": break;
+			default: t.push(f);
+		}
+		return m || t.push(c.editable.of(!1)), h || t.push(o.transactionFilter.of((e) => e.newDoc.lines > 1 ? [] : e)), g && t.push(o.readOnly.of(!0)), _ && (typeof _ == "boolean" ? t.unshift(e()) : t.unshift(e(_))), v && t.unshift(l(v)), typeof x == "function" && t.push(c.updateListener.of((e) => {
+			if (e.docChanged && typeof x == "function") {
+				let t = e.state.doc.toString();
+				E.current ? E.current = !1 : x(t, e);
+			}
+		})), t;
+	}, [
+		d,
+		p,
+		f,
+		m,
+		h,
+		g,
+		_,
+		v,
+		x
+	]);
+	return n(() => {
+		let e;
+		return S && typeof y == "string" && (e = new c({
+			state: o.create({
+				doc: y,
+				extensions: O
+			}),
+			parent: S
+		}), T(e)), () => {
+			e && (e.destroy(), T(void 0));
+		};
+	}, [S]), n(() => {
+		w?.state.doc.toString() !== y && w?.dispatch({ changes: {
+			from: 0,
+			to: w.state.doc.length,
+			insert: y || ""
+		} });
+	}, [y, w]), n(() => {
+		w && w.dispatch({ effects: s.reconfigure.of(O) });
+	}, [O, w]), n(() => {
+		if (typeof y == "string") {
+			let e = w ? w.state.doc.toString() : "";
+			w && y !== e && (E.current = !0, w.dispatch({ changes: {
+				from: 0,
+				to: e.length,
+				insert: y || ""
+			} }));
+		}
+	}, [y, w]), {
+		editorRef: D,
+		view: w
+	};
+};
+//#endregion
+export { d as default };

package/dist/components/CodeMirror/index.d.ts

@@ -0,0 +1,5 @@
+import { default as CodeMirror } from './CodeMirror';
+import { default as codeMirrorTheme } from './CodeMirror.styles';
+export * from './CodeMirror';
+export { codeMirrorTheme };
+export default CodeMirror;

package/dist/components/CodeMirror/index.js

@@ -0,0 +1,6 @@
+import e, { EditorState as t, Transaction as n } from "./CodeMirror.js";
+import r from "./CodeMirror.styles.js";
+//#region src/components/CodeMirror/index.ts
+var i = e;
+//#endregion
+export { t as EditorState, n as Transaction, r as codeMirrorTheme, i as default };

package/dist/components/ColorPicker/ColorPicker.d.ts

@@ -0,0 +1,22 @@
+import { default as ColorPickerStyles, variantKeys } from './ColorPicker.styles';
+import { ErrorMessageProps } from '../ErrorMessage';
+import { default as InputStyles } from '../Input/Input.styles';
+import { useThemeSharedProps } from '../../hooks/useTheme';
+import { InputHTMLAttributes, ReactNode, RefObject } from 'react';
+export type ColorPickerProps = {
+    ref?: RefObject<HTMLInputElement>;
+    label?: ReactNode;
+    placeholder?: string;
+    disabled?: boolean;
+    readOnly?: boolean;
+    error?: ErrorMessageProps['message'] | ErrorMessageProps['error'];
+    showAlpha?: boolean;
+    allowVariables?: boolean;
+    required?: boolean;
+    value?: string;
+    delayOnChange?: number;
+    allowedWords?: string[];
+    onChange?: (value: string) => void;
+} & Omit<InputHTMLAttributes<HTMLInputElement>, 'className' | 'onChange' | 'size'> & useThemeSharedProps<typeof ColorPickerStyles & typeof InputStyles, typeof variantKeys>;
+declare const _default: import('react').MemoExoticComponent<({ ref, className, id, label, placeholder, readOnly, required, disabled, showAlpha, allowVariables, value, error, size, intent, delayOnChange, allowedWords, onChange, ...inputProps }: ColorPickerProps) => import("react/jsx-runtime").JSX.Element>;
+export default _default;

package/dist/components/ColorPicker/ColorPicker.js

@@ -0,0 +1,101 @@
+import { debounce as e } from "../../helpers/lodash/debounce.js";
+import t from "../../hooks/useTheme/index.js";
+import n from "../Input/InputContainer.js";
+import r from "../../hooks/useDidUpdateEffect/index.js";
+import i from "../ContainerFloating/index.js";
+import { isValidVariable as a, objectToHex as o } from "./ColorPickerHelper.js";
+import { memo as s, useCallback as c, useMemo as l, useState as u } from "react";
+import { jsx as d, jsxs as f } from "react/jsx-runtime";
+import p from "@uiw/react-color-sketch";
+import m from "tinycolor2";
+var h = s(({ ref: s, className: h, id: g, label: _ = "", placeholder: v = "", readOnly: y = !1, required: b = !1, disabled: x = !1, showAlpha: S = !0, allowVariables: C = !1, value: w = "#ffffff", error: T, size: E, intent: D, delayOnChange: O = 250, allowedWords: k, onChange: A, ...j }) => {
+	let M = t("ColorPicker", {
+		className: h,
+		componentKey: [
+			"inputColorContainer",
+			"input",
+			"divider",
+			"colorContainer",
+			"alpha",
+			"alphaContainer"
+		],
+		variants: {
+			intent: D,
+			size: E
+		}
+	}), [N, P] = u(w), F = l(() => m(N), [N]), I = l(() => `${Math.round(F.getAlpha() * 100)}%`, [F]), L = l(() => F.isValid(), [F]), R = l(() => L ? `#${F.toHex()}` : "", [F, L]);
+	r(() => {
+		P(w);
+	}, [w]);
+	let z = l(() => O > 0 ? e((e) => A?.(o(e)), O) : (e) => A?.(o(e)), [O, A]), B = c((e) => {
+		z(e), P(o(e));
+	}, [z]), V = c((e) => {
+		P(e.target.value);
+	}, []), H = c(() => {
+		L || C && a(N) || k?.includes(N) ? A?.(N) : (A?.("#ffffff"), P("#ffffff"));
+	}, [
+		C,
+		k,
+		N,
+		L,
+		A
+	]);
+	return /* @__PURE__ */ d(n, {
+		className: h,
+		id: g,
+		label: _,
+		value: w,
+		disabled: x,
+		error: T,
+		intent: D,
+		size: E,
+		children: /* @__PURE__ */ f("div", {
+			className: M.inputColorContainer,
+			children: [
+				/* @__PURE__ */ f(i, {
+					closeOnClick: !1,
+					containerTopOffset: 5,
+					children: [/* @__PURE__ */ f(i.Trigger, {
+						className: M.colorContainer,
+						children: [/* @__PURE__ */ d("div", {
+							className: "h-full grow basis-0",
+							style: { backgroundColor: R }
+						}), /* @__PURE__ */ d("div", {
+							className: "h-full grow basis-0",
+							style: { backgroundColor: L ? N : "" }
+						})]
+					}), /* @__PURE__ */ d(i.Content, {
+						className: "z-802",
+						children: /* @__PURE__ */ d(p, {
+							color: N,
+							onChange: B
+						})
+					})]
+				}),
+				/* @__PURE__ */ d("div", { className: M.divider }),
+				/* @__PURE__ */ d("input", {
+					...j,
+					id: g,
+					ref: s,
+					placeholder: v,
+					readOnly: y,
+					required: b,
+					className: M.input,
+					type: "text",
+					value: N,
+					onChange: V,
+					onBlur: H
+				}),
+				S && L && /* @__PURE__ */ f("div", {
+					className: M.alphaContainer,
+					children: [/* @__PURE__ */ d("div", { className: M.divider }), /* @__PURE__ */ d("div", {
+						className: M.alpha,
+						children: `A: ${I}`
+					})]
+				})
+			]
+		})
+	});
+});
+//#endregion
+export { h as default };

package/dist/components/ColorPicker/ColorPicker.styles.d.ts

@@ -0,0 +1,27 @@
+export declare const variantKeys: {
+    readonly intent: readonly ["primary", "custom"];
+    readonly size: readonly ["md", "sm", "xs"];
+};
+export declare const STYLES_COMPONENT_NAME = "ColorPicker";
+declare const _default: {
+    inputColorContainer: (props?: ({
+        intent?: "custom" | "primary" | null | undefined;
+        size?: "xs" | "md" | "sm" | null | undefined;
+    } & import('class-variance-authority/types').ClassProp) | undefined) => string;
+    colorContainer: (props?: ({
+        size?: "xs" | "md" | "sm" | null | undefined;
+        disabled?: boolean | null | undefined;
+    } & import('class-variance-authority/types').ClassProp) | undefined) => string;
+    divider: (props?: import('class-variance-authority/types').ClassProp | undefined) => string;
+    input: (props?: ({
+        intent?: "primary" | null | undefined;
+        size?: "xs" | "md" | "sm" | "custom" | null | undefined;
+    } & import('class-variance-authority/types').ClassProp) | undefined) => string;
+    alphaContainer: (props?: ({
+        size?: "xs" | "md" | "sm" | null | undefined;
+    } & import('class-variance-authority/types').ClassProp) | undefined) => string;
+    alpha: (props?: ({
+        size?: "xs" | "md" | "sm" | null | undefined;
+    } & import('class-variance-authority/types').ClassProp) | undefined) => string;
+};
+export default _default;

package/dist/components/ColorPicker/ColorPicker.styles.js

@@ -0,0 +1,76 @@
+import e from "../../helpers/cvaWrapper.js";
+var t = {
+	inputColorContainer: e("flex w-full items-center dark:text-zinc-300", {
+		variants: {
+			intent: {
+				primary: "",
+				custom: ""
+			},
+			size: {
+				md: "gap-2",
+				sm: "gap-1.5",
+				xs: "gap-1"
+			}
+		},
+		compoundVariants: [],
+		defaultVariants: {
+			intent: "primary",
+			size: "md"
+		}
+	}),
+	colorContainer: e(["bg-[url('data:image/svg+xml;utf8,%3Csvg%20width%3D%226%22%20height%3D%226%22%20viewBox%3D%220%200%206%206%22%20fill%3D%22none%22%20xmlns%3D%22http%3A//www.w3.org/2000/svg%22%3E%3Cpath%20d%3D%22M0%200H3V3H0V0Z%22%20fill%3D%22%23E1E1E1%22/%3E%3Cpath%20d%3D%22M3%200H6V3H3V0Z%22%20fill%3D%22white%22/%3E%3Cpath%20d%3D%22M3%203H6V6H3V3Z%22%20fill%3D%22%23E1E1E1%22/%3E%3Cpath%20d%3D%22M0%203H3V6H0V3Z%22%20fill%3D%22white%22/%3E%3C/svg%3E%0A')]", "border border-gray-300 dark:border-zinc-700 flex rounded overflow-hidden shrink-0"], {
+		variants: {
+			size: {
+				md: "h-6 w-6",
+				sm: "h-5 w-5",
+				xs: "h-4 w-4"
+			},
+			disabled: {
+				true: "",
+				false: "cursor-pointer"
+			}
+		},
+		compoundVariants: [],
+		defaultVariants: {
+			size: "md",
+			disabled: !1
+		}
+	}),
+	divider: e("bg-gray-300 dark:bg-zinc-700 w-px self-stretch shrink-0"),
+	input: e("p-0 border-0 outline-none focus:ring-0 basis-0 grow min-w-2", {
+		variants: {
+			intent: { primary: "bg-white dark:bg-zinc-800 text-zinc-900 dark:text-zinc-200" },
+			size: {
+				md: "text-base",
+				sm: "text-sm",
+				xs: "text-xs",
+				custom: ""
+			}
+		},
+		compoundVariants: [],
+		defaultVariants: {
+			intent: "primary",
+			size: "md"
+		}
+	}),
+	alphaContainer: e("flex items-center overflow-hidden", {
+		variants: { size: {
+			md: "gap-2",
+			sm: "gap-1.5",
+			xs: "gap-1"
+		} },
+		compoundVariants: [],
+		defaultVariants: { size: "md" }
+	}),
+	alpha: e("block whitespace-nowrap truncate basis-0 grow text-zinc-900 dark:text-zinc-200", {
+		variants: { size: {
+			md: "",
+			sm: "text-sm",
+			xs: "text-xs"
+		} },
+		compoundVariants: [],
+		defaultVariants: { size: "md" }
+	})
+};
+//#endregion
+export { t as default };

package/dist/components/ColorPicker/ColorPickerHelper.d.ts

@@ -0,0 +1,3 @@
+import { ColorResult } from '@uiw/color-convert';
+export declare const objectToHex: (color: ColorResult) => string;
+export declare const isValidVariable: (value: string) => boolean;

package/dist/components/ColorPicker/ColorPickerHelper.js

@@ -0,0 +1,8 @@
+import e from "tinycolor2";
+//#region src/components/ColorPicker/ColorPickerHelper.ts
+var t = (t) => {
+	let { r: n, g: r, b: i, a } = t.rgba, o = e(`rgba(${n}, ${r}, ${i}, ${a})`);
+	return `#${a === 1 ? o.toHex() : o.toHex8()}`;
+}, n = /^(#([0-9a-fA-F]{3}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})|var\(--[a-zA-Z0-9_-]+\)|--[a-zA-Z0-9_-]+)$/, r = (e) => n.test(e.trim());
+//#endregion
+export { r as isValidVariable, t as objectToHex };

package/dist/components/ColorPicker/index.d.ts

@@ -0,0 +1,5 @@
+import { default as ColorPicker } from './ColorPicker';
+import { default as colorPickerTheme } from './ColorPicker.styles';
+export * from './ColorPicker';
+export { colorPickerTheme };
+export default ColorPicker;

package/dist/components/ColorPicker/index.js

@@ -0,0 +1,6 @@
+import e from "./ColorPicker.js";
+import t from "./ColorPicker.styles.js";
+//#region src/components/ColorPicker/index.ts
+var n = e;
+//#endregion
+export { t as colorPickerTheme, n as default };

package/dist/components/ContainerAutoScale/ContainerAutoScale.d.ts

@@ -0,0 +1,9 @@
+import { ReactNode } from 'react';
+export type ContainerAutoScaleProps = {
+    children?: ReactNode;
+    className?: string;
+    desiredHeight?: number;
+    desiredWidth?: number;
+};
+declare const ContainerAutoScale: ({ className, children, desiredHeight, desiredWidth }: ContainerAutoScaleProps) => import("react/jsx-runtime").JSX.Element;
+export default ContainerAutoScale;

package/dist/components/ContainerAutoScale/ContainerAutoScale.js

@@ -0,0 +1,43 @@
+import e from "./helpers/SizeFromDOM.js";
+import { useCallback as t, useLayoutEffect as n, useRef as r, useState as i } from "react";
+import { jsx as a } from "react/jsx-runtime";
+import o from "clsx";
+//#region src/components/ContainerAutoScale/ContainerAutoScale.tsx
+var s = ({ className: s = "", children: c, desiredHeight: l = 900, desiredWidth: u = 1440 }) => {
+	let [d, f] = i(0), [p, m] = i(0), h = r(null), g = t(() => {
+		let t = e(h.current);
+		if (!t) return;
+		let { width: n, height: r } = t;
+		f(r), m(n);
+	}, []);
+	n(() => {
+		let e;
+		return h.current && (e = new ResizeObserver(g), e.observe(h.current)), () => {
+			e && e.disconnect();
+		};
+	}, [g]);
+	let _ = p / u, v = d / l;
+	return _ > 1 && (_ = 1, u = p), /* @__PURE__ */ a("div", {
+		ref: h,
+		className: o(s),
+		style: { position: "relative" },
+		children: /* @__PURE__ */ a("div", {
+			style: {
+				position: "absolute",
+				transform: `scale(${_}, ${v})`,
+				transformOrigin: "0 0",
+				height: `${d}px`,
+				width: `${p}px`
+			},
+			children: /* @__PURE__ */ a("div", {
+				style: {
+					width: `${u}px`,
+					height: `${l}px`
+				},
+				children: c
+			})
+		})
+	});
+};
+//#endregion
+export { s as default };

package/dist/components/ContainerAutoScale/helpers/SizeFromDOM.d.ts

@@ -0,0 +1,19 @@
+declare const SizeFromDOM: (element?: HTMLElement | null) => {
+    width: number;
+    height: number;
+    paddingX: number;
+    paddingY: number;
+    borderX: number;
+    borderY: number;
+    raw: {
+        paddingLeft: string;
+        paddingTop: string;
+        paddingRight: string;
+        paddingBottom: string;
+        borderLeftWidth: string;
+        borderRightWidth: string;
+        borderTopWidth: string;
+        borderBottomWidth: string;
+    };
+} | undefined;
+export default SizeFromDOM;

package/dist/components/ContainerAutoScale/helpers/SizeFromDOM.js

@@ -0,0 +1,25 @@
+//#region src/components/ContainerAutoScale/helpers/SizeFromDOM.ts
+var e = (e) => {
+	if (!e) return;
+	let { offsetWidth: t, offsetHeight: n } = e, { paddingLeft: r, paddingTop: i, paddingRight: a, paddingBottom: o, borderLeftWidth: s, borderRightWidth: c, borderTopWidth: l, borderBottomWidth: u } = getComputedStyle(e), d = parseFloat(r) + parseFloat(a), f = parseFloat(i) + parseFloat(o), p = parseFloat(s) + parseFloat(c), m = parseFloat(l) + parseFloat(u);
+	return {
+		width: t - d - p,
+		height: n - f - m,
+		paddingX: d,
+		paddingY: f,
+		borderX: p,
+		borderY: m,
+		raw: {
+			paddingLeft: r,
+			paddingTop: i,
+			paddingRight: a,
+			paddingBottom: o,
+			borderLeftWidth: s,
+			borderRightWidth: c,
+			borderTopWidth: l,
+			borderBottomWidth: u
+		}
+	};
+};
+//#endregion
+export { e as default };

package/dist/components/ContainerAutoScale/index.d.ts

@@ -0,0 +1,3 @@
+import { default as ContainerAutoScale } from './ContainerAutoScale';
+export * from './ContainerAutoScale';
+export default ContainerAutoScale;

package/dist/components/ContainerAutoScale/index.js

@@ -0,0 +1,5 @@
+import e from "./ContainerAutoScale.js";
+//#region src/components/ContainerAutoScale/index.ts
+var t = e;
+//#endregion
+export { t as default };

package/dist/components/ContainerCollapsable/ContainerCollapsable.d.ts

@@ -0,0 +1,16 @@
+import { default as ContainerCollapsableStyles, variantKeys } from './ContainerCollapsable.styles';
+import { ContainerCollapsableHeaderProps } from './ContainerCollapsableHeader';
+import { variantKeys as variantKeysFlex } from '../Flex/Flex.styles';
+import { useThemeSharedProps } from '../../hooks/useTheme';
+import { HTMLAttributes, ReactNode } from 'react';
+export type ContainerCollapsableProps = {
+    collapsed?: boolean;
+    children?: ReactNode;
+    onChange?: (collapsed: boolean) => void;
+} & Omit<HTMLAttributes<HTMLDivElement>, 'className' | 'onChange'> & useThemeSharedProps<typeof ContainerCollapsableStyles, typeof variantKeys & typeof variantKeysFlex>;
+declare const ContainerCollapsable: {
+    ({ className, collapsed: collapsedProp, children, direction, wrap, items, justify, gap, grow, shrink, basis, onChange, ...otherProps }: ContainerCollapsableProps): import("react/jsx-runtime").JSX.Element;
+    Header: ({ children, className, title, collapsed, iconCollapsed, iconExpanded, placement, onClick, ...otherProps }: ContainerCollapsableHeaderProps) => import("react/jsx-runtime").JSX.Element;
+    Content: ({ className, children, direction, wrap, items, justify, gap, grow, shrink, basis, ...otherProps }: import('./ContainerCollapsableContent').ContainerCollapsableContentProps) => import("react/jsx-runtime").JSX.Element;
+};
+export default ContainerCollapsable;