@fuzzy-ui/react 0.1.0

package/dist/types/utils/forward.d.ts

@@ -0,0 +1,6 @@
+import type { ForwardRefRenderFunction, ForwardRefExoticComponent, PropsWithoutRef, RefAttributes, ComponentRef, ComponentPropsWithoutRef, ElementType } from 'react';
+type RefEle<T> = T extends ElementType ? ComponentRef<T> : T extends Element ? T : never;
+type Props<T extends ElementType, P = {}> = PropsWithoutRef<Omit<ComponentPropsWithoutRef<T>, keyof P> & P>;
+export type Component<T extends ElementType, P = {}> = ForwardRefExoticComponent<Props<T, P> & RefAttributes<RefEle<T>>>;
+export declare function forwardRef<T extends ElementType, P = {}>(render: ForwardRefRenderFunction<RefEle<T>, Props<T, P>>): Component<T, P>;
+export {};

package/dist/types/utils/index.d.ts

@@ -0,0 +1,14 @@
+export * from './forward';
+export { default as WithWrapper } from './WithWrapper';
+export { default as checkChild } from './children';
+export { default as deepMerge } from './deepMerge';
+export { default as uniqueStr } from './unique.str';
+export { default as range } from './range';
+export { default as closest } from './closest';
+export { default as clamp } from './clamp';
+export { default as typeis } from './typeis';
+export { default as textTransform } from './textTransform';
+export { default as getScreen } from './screen';
+export { stringFilter, stringPattern, numberFilter, numberPattern } from './simpleStrFilter';
+export { composeRefs, useComposedRefs } from './composeRefs';
+export * from './autoResize';

package/dist/types/utils/range.d.ts

@@ -0,0 +1 @@
+export default function (length?: number, start?: number): number[];

package/dist/types/utils/screen.d.ts

@@ -0,0 +1,31 @@
+import type { ScreenProps } from './types';
+declare const range: {
+    xs: {
+        min: string;
+        max: string;
+    };
+    sm: {
+        min: string;
+        max: string;
+    };
+    md: {
+        min: string;
+        max: string;
+    };
+    lg: {
+        min: string;
+        max: string;
+    };
+    xl: {
+        min: string;
+        max: string;
+    };
+    xxl: {
+        min: string;
+        max: undefined;
+    };
+};
+/** The **max** value of the largest size will be returned as **undefined**. */
+export default function ({ get, size }?: Screen): string | undefined;
+type Screen = ScreenProps<typeof range>;
+export {};

package/dist/types/utils/simpleStrFilter.d.ts

@@ -0,0 +1,36 @@
+declare const STROPTS: {
+    alphabet: boolean;
+    number: boolean;
+    symbol: boolean;
+    whitespace: boolean;
+    asUnicode: boolean;
+    includes: never[];
+    includesAtStart: never[];
+    excludes: never[];
+    excludesAtStart: never[];
+}, CNAME: readonly ["alphabet", "number", "symbol", "whitespace"];
+declare const NUMOPTS: {
+    negative: boolean;
+    decimal: boolean;
+    eNotation: boolean;
+    strict: {
+        leadingZeros: boolean;
+        trailingZeros: boolean;
+    };
+};
+export declare function stringFilter(str?: string, options?: StringOptions): string;
+export declare function stringPattern(options?: StringOptions): RegExp;
+export declare function numberFilter(str?: string, options?: NumberOptions): string;
+export declare function numberPattern(options?: NumberOptions): RegExp;
+type stringChars = string & {};
+type SO = typeof STROPTS;
+type StringOptions = {
+    [K in keyof SO]?: SO[K] extends Array<any> ? ((typeof CNAME)[number] | stringChars)[] : SO[K];
+};
+type NO = typeof NUMOPTS;
+type NumberOptions = {
+    [K in keyof NO]?: K extends 'strict' ? boolean | {
+        [I in keyof NO[K]]?: I extends 'leadingZeros' ? NO[K][I] | 'num' | 'exp' : NO[K][I];
+    } : NO[K];
+};
+export {};

package/dist/types/utils/textTransform.d.ts

@@ -0,0 +1,9 @@
+import type { TransformProps } from './types';
+declare const transform: {
+    capitalize: (txt: string) => string;
+    lowercase: (txt: string) => string;
+    uppercase: (txt: string) => string;
+};
+export default function ({ text, to }?: Transform): string | undefined;
+type Transform = TransformProps<typeof transform>;
+export {};

package/dist/types/utils/typeis.d.ts

@@ -0,0 +1,10 @@
+declare const rVal: readonly ["reactelement", "reactfragment", "reactsuspense", "reactprovider", "reactcontext", "reactportal", "reactcomponent"], aVal: readonly ["htmlelement", "nan", "stringnumber", "stringhtml", "class", "function", "asyncfunction", "generatorfunction", "null", "undefined", "boolean", "number", "string", "symbol", "object", "array", "date", "error", "regexp", "set", "map", "weakset", "weakmap", "promise", "bigint", "window", "htmldocument", "navigator"];
+/**
+ * Get better typeof value.
+ *
+ * This function returns a bit more detail of the type of value in a string and includes several types such as Primitive data types, Structured data types, Functions, React-specific data types, and
+Other additional data types.
+ */
+export default function (value: unknown): ValueType;
+type ValueType = (typeof rVal)[number] | (typeof aVal)[number] | (string & {});
+export {};

package/dist/types/utils/types.d.ts

@@ -0,0 +1,35 @@
+export type TransformProps<T> = {
+    text?: string;
+    to?: keyof T;
+};
+export type ScreenProps<T> = {
+    get?: 'min' | 'max';
+    size?: keyof T;
+};
+export declare const tuple: <T extends unknown[] | [] | readonly unknown[]>(...args: [...T]) => T;
+type ObjU<O extends Record<any, unknown>, R extends boolean> = {
+    [K in keyof O as undefined extends O[K] ? R extends true ? K : never : R extends true ? never : K]: O[K];
+};
+/**
+ * Get or exclude object properties with undefined values.
+ * ```ts
+ * Ondefined<Object, KeysOnly?, Reverse?>
+ * ```
+ */
+export type Ondefined<O extends Record<any, unknown>, K extends boolean = false, R extends boolean = false> = K extends true ? keyof ObjU<O, R> : ObjU<O, R>;
+type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+type UnionToOvlds<U> = UnionToIntersection<U extends any ? (f: U) => void : never>;
+type PopUnion<U> = UnionToOvlds<U> extends (a: infer A) => void ? A : never;
+type IsUnion<T> = [T] extends [UnionToIntersection<T>] ? false : true;
+export type UnionToArray<T, A extends unknown[] = []> = IsUnion<T> extends true ? UnionToArray<Exclude<T, PopUnion<T>>, [PopUnion<T>, ...A]> : [T, ...A];
+export type SplitStr<S extends string, D extends string> = string extends S ? string[] : S extends '' ? [] : S extends `${infer T}${D}${infer U}` ? [T, ...SplitStr<U, D>] : [S];
+export type ObjectKeys<T extends object> = UnionToArray<keyof T>;
+type Tail<T extends string[]> = T extends [string, ...infer TailType] ? TailType : never;
+type JoinRecursive<H extends string, T extends string[], Separator extends string> = Tail<T> extends [string, ...string[]] ? `${H}${Separator}${JoinRecursive<T[0], Tail<T>, Separator>}` : `${H}${Separator}${T[0]}`;
+export type JoinStr<T extends string[], Separator extends string> = Tail<T> extends string[] ? JoinRecursive<T[0], Tail<T>, Separator> : T[0];
+export type LastChar<T extends string | unknown> = T extends `${infer F}${infer R}` ? R extends '' ? F : LastChar<R> : never;
+export type LastItem<T extends any[]> = T extends [...infer _, infer L] ? L : never;
+export type Includes<T extends any[], C extends any> = {
+    [I in keyof T]: T[I] extends C ? unknown : never;
+}[number] extends never ? false : true;
+export {};

package/dist/types/utils/unique.str.d.ts

@@ -0,0 +1 @@
+export default function (arr: any[]): string[];

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@fuzzy-ui/react",
+  "version": "0.1.0",
+  "type": "module",
+  "main": "./dist/cjs/index.js",
+  "module": "./dist/esm/index.js",
+  "types": "./dist/types/index.d.ts",
+  "sideEffects": false,
+  "license": "MIT",
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "directory": "dist",
+    "access": "public"
+  },
+  "scripts": {
+    "cleanup": "rm -rf dist node_modules .turbo .swc",
+    "clean": "rm -rf dist",
+    "accident": "node ./scripts/accident.js",
+    "pkg": "node ./scripts/maps.js",
+    "build": "pnpm run clean && rollup -c && pnpm run pkg",
+    "build:ui": "pnpm run build",
+    "dev": "rollup -c -w && tsc -w"
+  },
+  "dependencies": {
+    "@radix-ui/react-compose-refs": "^1.1.2",
+    "@radix-ui/react-dialog": "^1.1.14",
+    "@radix-ui/react-navigation-menu": "^1.2.13",
+    "@radix-ui/react-popover": "^1.1.15",
+    "@radix-ui/react-portal": "^1.1.9",
+    "@radix-ui/react-presence": "^1.1.4",
+    "@radix-ui/react-select": "^2.2.6",
+    "@radix-ui/react-slider": "^1.3.5",
+    "@radix-ui/react-slot": "^1.2.3",
+    "@radix-ui/react-tooltip": "^1.2.7",
+    "@stitches/core": "1.3.1-1",
+    "@zag-js/auto-resize": "^1.33.1",
+    "deepmerge": "^4.3.1"
+  },
+  "peerDependencies": {
+    "react": ">=16.8.0",
+    "react-dom": ">=16.8.0"
+  },
+  "devDependencies": {
+    "@rollup/plugin-commonjs": "^28.0.3",
+    "@rollup/plugin-node-resolve": "^16.0.1",
+    "@swc/core": "^1.11.31",
+    "react": "catalog:",
+    "react-dom": "catalog:",
+    "rollup": "^4.42.0",
+    "rollup-plugin-peer-deps-external": "^2.2.4",
+    "rollup-plugin-swc3": "^0.12.1",
+    "rollup-plugin-typescript2": "^0.36.0",
+    "rollup-preserve-directives": "^1.1.3"
+  }
+}