figma-kit 1.0.0-beta.3 → 1.0.0-beta.31

package/dist/lib/color.d.ts

@@ -0,0 +1,40 @@
+type WithAlpha<T> = T & {
+    a: number;
+};
+type RGB = {
+    r: number;
+    g: number;
+    b: number;
+};
+type HSV = {
+    h: number;
+    s: number;
+    v: number;
+};
+type HSL = {
+    h: number;
+    s: number;
+    l: number;
+};
+type RGBA = WithAlpha<RGB>;
+type HSVA = WithAlpha<HSV>;
+type HSLA = WithAlpha<HSL>;
+type HEX = string;
+type P3String = `color(display-p3 ${number} ${number} ${number}${` / ${number}` | ''})`;
+type RGBString = `rgb(${number} ${number} ${number}${` / ${number}` | ''})`;
+declare function rgbaToHex({ r, g, b, a }: RGBA): HEX;
+declare function hslaToHex(hsla: HSLA): HEX;
+declare function hsvaToHex(hsla: HSVA): HEX;
+declare function rgbaToHsva({ r, g, b, a }: RGBA): HSVA;
+declare function hsvaToRgba({ h, s, v, a }: HSVA): RGBA;
+declare function hslaToHsva({ h, s, l, a }: HSLA): HSVA;
+declare function hsvaToHsla({ h, s, v, a }: HSVA): HSLA;
+declare function hslaToRgba(hsla: HSLA): RGBA;
+declare function rgbaToHsla(rgba: RGBA): HSLA;
+declare function rgbaToP3String(color: RGBA): P3String;
+declare function rgbaToCssString(color: RGBA): RGBString;
+declare function blendWithWhite(color: RGBA): RGBA;
+declare function roundHsva(hsva: HSVA): HSVA;
+declare function roundHsla(hsla: HSLA): HSLA;
+export type { RGB, HSV, HSL, RGBA, HSVA, HSLA, HEX, P3String, RGBString };
+export { rgbaToHex, rgbaToHsva, hsvaToRgba, hslaToHsva, hsvaToHsla, hslaToRgba, rgbaToHsla, rgbaToP3String, rgbaToCssString, blendWithWhite, roundHsva, roundHsla, hslaToHex, hsvaToHex, };

package/dist/lib/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const DEFAULT_SMALL_NUDGE = 1;
+export declare const DEFAULT_BIG_NUDGE = 10;

package/dist/lib/dom/focus.d.ts

@@ -0,0 +1,14 @@
+type FocusableTarget = HTMLElement | {
+    focus(): void;
+};
+/**
+ * Focus a given element and optionally select its content if it is a selectable input.
+ *
+ * @param element - The element to focus. Optional.
+ * @param options
+ * @param options.select - Whether to select the content of the element if it is a selectable input (default: false).
+ */
+export declare function focus(element?: FocusableTarget | null, { select }?: {
+    select?: boolean | undefined;
+}): void;
+export {};

package/dist/lib/dom/set-input-value.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Set the value of an HTMLInputElement and optionally dispatch an input event.
+ *
+ * @param inputElement - The HTMLInputElement to set the value for.
+ * @param value - The value to set on the input element.
+ * @param dispatchEvent - Whether to dispatch an input event (default: true).
+ */
+export declare const setInputElementValue: (inputElement: HTMLInputElement | null, value: string, dispatchEvent?: boolean) => void;

package/dist/lib/number/clamp.d.ts

@@ -0,0 +1 @@
+export declare function clamp(value: number, min: number, max?: number): number;

package/dist/lib/number/normalize.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Map a value to a specified range.
+ * https://stats.stackexchange.com/a/281164
+ *
+ * @param sourceRange {[number, number]} - input range
+ * @param targetRange {[number, number]} - The target range to map the value to
+ * @return {function(number): number} A function that takes a number and maps it to the specified range
+ *
+ * @example:
+ * normalize([0, 1], [0, 100])(0.5) -> 50
+ * normalize([0, 1], [0, 255])(1) -> 255
+ */
+export declare function normalize(sourceRange: [number, number], targetRange: [number, number]): (value: number) => number;

package/dist/lib/react/add-class-name.d.ts

@@ -0,0 +1,4 @@
+type ClassName<State> = string | ((state: State) => string | undefined) | undefined;
+declare function addClassName<State>(className: ClassName<State>, value: string): ClassName<State>;
+export type { ClassName };
+export { addClassName };

package/dist/lib/react/create-context.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @license
+ * MIT License
+ * Copyright (c) 2022 WorkOS
+ * https://github.com/radix-ui/primitives/blob/main/LICENSE
+ * */
+import React from 'react';
+declare function createContext<ContextValueType extends object | null>(rootComponentName: string, defaultContext?: ContextValueType): readonly [{
+    (props: ContextValueType & {
+        children: React.ReactNode;
+    }): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+}, (consumerName: string) => ContextValueType];
+export { createContext };

package/dist/lib/react/use-compose-refs.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @license
+ * MIT License
+ * Copyright (c) 2022 WorkOS
+ * https://github.com/radix-ui/primitives/blob/main/LICENSE
+ * */
+import * as React from 'react';
+type PossibleRef<T> = React.Ref<T> | undefined;
+/**
+ * A utility to compose multiple refs together
+ * Accepts callback refs and RefObject(s)
+ */
+declare function composeRefs<T>(...refs: PossibleRef<T>[]): (node: T) => void;
+/**
+ * A custom hook that composes multiple refs
+ * Accepts callback refs and RefObject(s)
+ */
+declare function useComposedRefs<T>(...refs: PossibleRef<T>[]): (node: T) => void;
+export { composeRefs, useComposedRefs };

package/dist/lib/react/use-controllable-state.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @license
+ * MIT License
+ * Copyright (c) 2022 WorkOS
+ * https://github.com/radix-ui/primitives/blob/main/LICENSE
+ * */
+import * as React from 'react';
+type UseControllableStateParams<T> = {
+    prop?: T | undefined;
+    defaultProp?: T | undefined;
+    onChange?: (state: T) => void;
+};
+declare function useControllableState<T>({ prop, defaultProp, onChange }: UseControllableStateParams<T>): readonly [T | undefined, React.Dispatch<React.SetStateAction<T | undefined>>];
+export { useControllableState };

package/dist/lib/react/use-select-on-input-click.d.ts

@@ -0,0 +1,9 @@
+import type React from 'react';
+/**
+ * Selects the target element's contents on click, unless the user is selecting manually.
+ * */
+export declare function useSelectOnInputClick(): {
+    onMouseLeave: () => void;
+    onMouseUp: (event: React.MouseEvent<HTMLInputElement>) => void;
+    onFocus: () => void;
+};