@yugu-ui/shared 0.0.0-stage → 0.1.0

package/dist/nanoid-CQE6QAZJ.js

@@ -0,0 +1,2 @@
+import { nanoid } from "nanoid";
+export { nanoid as t };

package/dist/request/constant.d.ts

@@ -0,0 +1,6 @@
+/** request id key */
+export declare const REQUEST_ID_KEY = "X-Request-Id";
+/** the backend error code key */
+export declare const BACKEND_ERROR_CODE = "BACKEND_ERROR";
+/** the request canceled code */
+export declare const REQUEST_CANCELED_CODE = "ERR_CANCELED";

package/dist/request/index.d.ts

@@ -0,0 +1,22 @@
+import { AxiosError, CreateAxiosDefaults } from 'axios';
+import { BACKEND_ERROR_CODE, REQUEST_CANCELED_CODE, REQUEST_ID_KEY } from './constant';
+import { FlatRequestInstance, RequestInstance, RequestOption } from './type';
+/**
+ * create a request instance
+ *
+ * @param axiosConfig axios config
+ * @param options request options
+ */
+export declare function createRequest<ResponseData, ApiData, State extends Record<string, unknown>>(axiosConfig?: CreateAxiosDefaults, options?: Partial<RequestOption<ResponseData, ApiData, State>>): RequestInstance<ApiData, State>;
+/**
+ * create a flat request instance
+ *
+ * The response data is a flat object: { data: any, error: AxiosError }
+ *
+ * @param axiosConfig axios config
+ * @param options request options
+ */
+export declare function createFlatRequest<ResponseData, ApiData, State extends Record<string, unknown>>(axiosConfig?: CreateAxiosDefaults, options?: Partial<RequestOption<ResponseData, ApiData, State>>): FlatRequestInstance<ResponseData, ApiData, State>;
+export { BACKEND_ERROR_CODE, REQUEST_CANCELED_CODE, REQUEST_ID_KEY };
+export type * from './type';
+export type { CreateAxiosDefaults, AxiosError };

package/dist/request/options.d.ts

@@ -0,0 +1,6 @@
+import { CreateAxiosDefaults } from 'axios';
+import { IAxiosRetryConfig } from 'axios-retry';
+import { RequestOption } from './type';
+export declare function createDefaultOptions<ResponseData, ApiData = ResponseData, State extends Record<string, unknown> = Record<string, unknown>>(options?: Partial<RequestOption<ResponseData, ApiData, State>>): RequestOption<ResponseData, ApiData, State>;
+export declare function createRetryOptions(config?: Partial<CreateAxiosDefaults>): IAxiosRetryConfig;
+export declare function createAxiosConfig(config?: Partial<CreateAxiosDefaults>): CreateAxiosDefaults<any>;

package/dist/request/shared.d.ts

@@ -0,0 +1,17 @@
+import { AxiosResponse, InternalAxiosRequestConfig } from 'axios';
+export declare function getContentType(config: InternalAxiosRequestConfig): string | number | true | string[] | import('axios').AxiosHeaders;
+/**
+ * check if http status is success
+ *
+ * @param status
+ */
+export declare function isHttpSuccess(status: number): boolean;
+/**
+ * is response json
+ *
+ * @param response axios response
+ */
+export declare function isResponseJson(response: AxiosResponse): boolean;
+export declare function transformResponse(response: AxiosResponse): Promise<void>;
+export declare function transformBlobToJson(response: AxiosResponse): Promise<void>;
+export declare function transformArrayBufferToJson(response: AxiosResponse): Promise<void>;

package/dist/request/type.d.ts

@@ -0,0 +1,94 @@
+import { AxiosError, AxiosInstance, AxiosRequestConfig, AxiosResponse, InternalAxiosRequestConfig } from 'axios';
+export type ContentType = 'text/html' | 'text/plain' | 'multipart/form-data' | 'application/json' | 'application/x-www-form-urlencoded' | 'application/octet-stream';
+export type ResponseTransform<Input = any, Output = any> = (input: Input) => Output | Promise<Output>;
+export interface RequestOption<ResponseData, ApiData = ResponseData, State extends Record<string, unknown> = Record<string, unknown>> {
+    /**
+     * The default state
+     */
+    defaultState?: State;
+    /**
+     * transform the response data to the api data
+     *
+     * @param response Axios response
+     */
+    transform: ResponseTransform<AxiosResponse<ResponseData>, ApiData>;
+    /**
+     * transform the response data to the api data
+     *
+     * @deprecated use `transform` instead, will be removed in the next major version v3
+     * @param response Axios response
+     */
+    transformBackendResponse: ResponseTransform<AxiosResponse<ResponseData>, ApiData>;
+    /**
+     * The hook before request
+     *
+     * For example: You can add header token in this hook
+     *
+     * @param config Axios config
+     */
+    onRequest: (config: InternalAxiosRequestConfig) => InternalAxiosRequestConfig | Promise<InternalAxiosRequestConfig>;
+    /**
+     * The hook to check backend response is success or not
+     *
+     * @param response Axios response
+     */
+    isBackendSuccess: (response: AxiosResponse<ResponseData>) => boolean;
+    /**
+     * The hook after backend request fail
+     *
+     * For example: You can handle the expired token in this hook
+     *
+     * @param response Axios response
+     * @param instance Axios instance
+     */
+    onBackendFail: (response: AxiosResponse<ResponseData>, instance: AxiosInstance) => Promise<AxiosResponse | null> | Promise<void>;
+    /**
+     * The hook to handle error
+     *
+     * For example: You can show error message in this hook
+     *
+     * @param error
+     */
+    onError: (error: AxiosError<ResponseData>) => void | Promise<void>;
+}
+interface ResponseMap {
+    blob: Blob;
+    text: string;
+    arrayBuffer: ArrayBuffer;
+    stream: ReadableStream<Uint8Array>;
+    document: Document;
+}
+export type ResponseType = keyof ResponseMap | 'json';
+export type MappedType<R extends ResponseType, JsonType = any> = R extends keyof ResponseMap ? ResponseMap[R] : JsonType;
+export type CustomAxiosRequestConfig<R extends ResponseType = 'json'> = Omit<AxiosRequestConfig, 'responseType'> & {
+    responseType?: R;
+};
+export interface RequestInstanceCommon<State extends Record<string, unknown>> {
+    /**
+     * cancel all request
+     *
+     * if the request provide abort controller sign from config, it will not collect in the abort controller map
+     */
+    cancelAllRequest: () => void;
+    /** you can set custom state in the request instance */
+    state: State;
+}
+/** The request instance */
+export interface RequestInstance<ApiData, State extends Record<string, unknown>> extends RequestInstanceCommon<State> {
+    <T extends ApiData = ApiData, R extends ResponseType = 'json'>(config: CustomAxiosRequestConfig<R>): Promise<MappedType<R, T>>;
+}
+export type FlatResponseSuccessData<ResponseData, ApiData> = {
+    data: ApiData;
+    error: null;
+    response: AxiosResponse<ResponseData>;
+};
+export type FlatResponseFailData<ResponseData> = {
+    data: null;
+    error: AxiosError<ResponseData>;
+    response: AxiosResponse<ResponseData>;
+};
+export type FlatResponseData<ResponseData, ApiData> = FlatResponseSuccessData<ResponseData, ApiData> | FlatResponseFailData<ResponseData>;
+export interface FlatRequestInstance<ResponseData, ApiData, State extends Record<string, unknown>> extends RequestInstanceCommon<State> {
+    <T extends ApiData = ApiData, R extends ResponseType = 'json'>(config: CustomAxiosRequestConfig<R>): Promise<FlatResponseData<ResponseData, MappedType<R, T>>>;
+}
+export {};

package/dist/request.d.ts

@@ -0,0 +1,2 @@
+export * from './request/index.js'
+export {}

package/dist/request.js

@@ -0,0 +1,182 @@
+import { t as nanoid } from "./nanoid-CQE6QAZJ.js";
+import { AxiosError, create } from "axios";
+import axiosRetry from "axios-retry";
+import { stringify } from "qs";
+//#region src/request/shared.ts
+/**
+* check if http status is success
+*
+* @param status
+*/
+function isHttpSuccess(status) {
+	return status >= 200 && status < 300 || status === 304;
+}
+async function transformResponse(response) {
+	const responseType = response.config?.responseType || "json";
+	if (responseType === "json") return;
+	if (!response.headers["content-type"]?.includes("application/json")) return;
+	if (responseType === "blob") await transformBlobToJson(response);
+	if (responseType === "arrayBuffer") await transformArrayBufferToJson(response);
+}
+async function transformBlobToJson(response) {
+	try {
+		let data = response.data;
+		if (typeof data === "string") data = JSON.parse(data);
+		if (Object.prototype.toString.call(data) === "[object Blob]") {
+			const json = await data.text();
+			data = JSON.parse(json);
+		}
+		response.data = data;
+	} catch {}
+}
+async function transformArrayBufferToJson(response) {
+	try {
+		let data = response.data;
+		if (typeof data === "string") data = JSON.parse(data);
+		if (Object.prototype.toString.call(data) === "[object ArrayBuffer]") {
+			const json = new TextDecoder().decode(data);
+			data = JSON.parse(json);
+		}
+		response.data = data;
+	} catch {}
+}
+//#endregion
+//#region src/request/options.ts
+function createDefaultOptions(options) {
+	const opts = {
+		defaultState: {},
+		transform: async (response) => response.data,
+		transformBackendResponse: async (response) => response.data,
+		onRequest: async (config) => config,
+		isBackendSuccess: (_response) => true,
+		onBackendFail: async () => {},
+		onError: async () => {}
+	};
+	if (options?.transform) opts.transform = options.transform;
+	else opts.transform = options?.transformBackendResponse || opts.transform;
+	Object.assign(opts, options);
+	return opts;
+}
+function createRetryOptions(config) {
+	const retryConfig = { retries: 0 };
+	Object.assign(retryConfig, config);
+	return retryConfig;
+}
+function createAxiosConfig(config) {
+	const axiosConfig = {
+		timeout: 10 * 1e3,
+		headers: { "Content-Type": "application/json" },
+		validateStatus: isHttpSuccess,
+		paramsSerializer: (params) => {
+			return stringify(params);
+		}
+	};
+	Object.assign(axiosConfig, config);
+	return axiosConfig;
+}
+//#endregion
+//#region src/request/constant.ts
+/** request id key */
+var REQUEST_ID_KEY = "X-Request-Id";
+/** the backend error code key */
+var BACKEND_ERROR_CODE = "BACKEND_ERROR";
+/** the request canceled code */
+var REQUEST_CANCELED_CODE = "ERR_CANCELED";
+//#endregion
+//#region src/request/index.ts
+function createCommonRequest(axiosConfig, options) {
+	const opts = createDefaultOptions(options);
+	const axiosConf = createAxiosConfig(axiosConfig);
+	const instance = create(axiosConf);
+	const abortControllerMap = /* @__PURE__ */ new Map();
+	axiosRetry(instance, createRetryOptions(axiosConf));
+	instance.interceptors.request.use((conf) => {
+		const config = { ...conf };
+		const requestId = nanoid();
+		config.headers.set(REQUEST_ID_KEY, requestId);
+		if (!config.signal) {
+			const abortController = new AbortController();
+			config.signal = abortController.signal;
+			abortControllerMap.set(requestId, abortController);
+		}
+		return opts.onRequest?.(config) || config;
+	});
+	instance.interceptors.response.use(async (response) => {
+		const responseType = response.config?.responseType || "json";
+		await transformResponse(response);
+		if (responseType !== "json" || opts.isBackendSuccess(response)) return Promise.resolve(response);
+		const fail = await opts.onBackendFail(response, instance);
+		if (fail) return fail;
+		const backendError = new AxiosError("请求失败，请联系管理员", BACKEND_ERROR_CODE, response.config, response.request, response);
+		await opts.onError(backendError);
+		return Promise.reject(backendError);
+	}, async (error) => {
+		await opts.onError(error);
+		return Promise.reject(error);
+	});
+	function cancelAllRequest() {
+		abortControllerMap.forEach((abortController) => {
+			abortController.abort();
+		});
+		abortControllerMap.clear();
+	}
+	return {
+		instance,
+		opts,
+		cancelAllRequest
+	};
+}
+/**
+* create a request instance
+*
+* @param axiosConfig axios config
+* @param options request options
+*/
+function createRequest(axiosConfig, options) {
+	const { instance, opts, cancelAllRequest } = createCommonRequest(axiosConfig, options);
+	const request = async function request(config) {
+		const response = await instance(config);
+		if ((response.config?.responseType || "json") === "json") return opts.transform(response);
+		return response.data;
+	};
+	request.cancelAllRequest = cancelAllRequest;
+	request.state = {};
+	return request;
+}
+/**
+* create a flat request instance
+*
+* The response data is a flat object: { data: any, error: AxiosError }
+*
+* @param axiosConfig axios config
+* @param options request options
+*/
+function createFlatRequest(axiosConfig, options) {
+	const { instance, opts, cancelAllRequest } = createCommonRequest(axiosConfig, options);
+	const flatRequest = async function flatRequest(config) {
+		try {
+			const response = await instance(config);
+			if ((response.config?.responseType || "json") === "json") return {
+				data: await opts.transform(response),
+				error: null,
+				response
+			};
+			return {
+				data: response.data,
+				error: null,
+				response
+			};
+		} catch (error) {
+			return {
+				data: null,
+				error,
+				response: error.response
+			};
+		}
+	};
+	flatRequest.cancelAllRequest = cancelAllRequest;
+	flatRequest.state = { ...opts.defaultState };
+	return flatRequest;
+}
+//#endregion
+export { BACKEND_ERROR_CODE, REQUEST_CANCELED_CODE, REQUEST_ID_KEY, createFlatRequest, createRequest };

package/dist/scripts/src/commands/changelog.d.ts

@@ -0,0 +1,2 @@
+import { ChangelogOption } from '@soybeanjs/changelog';
+export declare function genChangelog(options?: Partial<ChangelogOption>, total?: boolean): Promise<void>;

package/dist/scripts/src/commands/cleanup.d.ts

@@ -0,0 +1 @@
+export declare function cleanup(paths: string[]): Promise<void>;

package/dist/scripts/src/commands/git-commit.d.ts

@@ -0,0 +1,9 @@
+import { Lang } from '../locales';
+/**
+ * Git commit with Conventional Commits standard
+ *
+ * @param lang
+ */
+export declare function gitCommit(lang?: Lang): Promise<void>;
+/** Git commit message verify */
+export declare function gitCommitVerify(lang?: Lang, ignores?: RegExp[]): Promise<void>;

package/dist/scripts/src/commands/index.d.ts

@@ -0,0 +1,6 @@
+export * from './git-commit';
+export * from './cleanup';
+export * from './update-pkg';
+export * from './changelog';
+export * from './release';
+export * from './router';

package/dist/scripts/src/commands/release.d.ts

@@ -0,0 +1 @@
+export declare function release(execute?: string, push?: boolean): Promise<void>;

package/dist/scripts/src/commands/router.d.ts

@@ -0,0 +1,2 @@
+/** generate route */
+export declare function generateRoute(): Promise<void>;

package/dist/scripts/src/commands/update-pkg.d.ts

@@ -0,0 +1 @@
+export declare function updatePkg(args?: string[]): Promise<void>;

package/dist/scripts/src/config/index.d.ts

@@ -0,0 +1,2 @@
+import { CliOption } from '../types';
+export declare function loadCliOptions(overrides?: Partial<CliOption>, cwd?: string): Promise<CliOption>;

package/dist/scripts/src/index.d.ts

@@ -0,0 +1 @@
+export declare function setupCli(): Promise<void>;

package/dist/scripts/src/locales/index.d.ts

@@ -0,0 +1,25 @@
+export type Lang = 'zh-cn' | 'en-us';
+export declare const locales: {
+    'zh-cn': {
+        gitCommitMessages: {
+            types: string;
+            scopes: string;
+            description: string;
+        };
+        gitCommitTypes: [string, string][];
+        gitCommitScopes: [string, string][];
+        gitCommitNoStaged: string;
+        gitCommitVerify: string;
+    };
+    'en-us': {
+        gitCommitMessages: {
+            types: string;
+            scopes: string;
+            description: string;
+        };
+        gitCommitTypes: [string, string][];
+        gitCommitScopes: [string, string][];
+        gitCommitNoStaged: string;
+        gitCommitVerify: string;
+    };
+};

package/dist/scripts/src/shared/index.d.ts

@@ -0,0 +1,2 @@
+import { Options } from 'execa';
+export declare function execCommand(cmd: string, args: string[], options?: Options): Promise<string>;

package/dist/scripts/src/types/index.d.ts

@@ -0,0 +1,30 @@
+import { ChangelogOption } from '@soybeanjs/changelog';
+export interface CliOption {
+    /** The project root directory */
+    cwd: string;
+    /**
+     * Cleanup dirs
+     *
+     * Glob pattern syntax {@link https://github.com/isaacs/minimatch}
+     *
+     * @default
+     * ```json
+     * ["** /dist", "** /pnpm-lock.yaml", "** /node_modules", "!node_modules/**"]
+     * ```
+     */
+    cleanupDirs: string[];
+    /**
+     * Npm-check-updates command args
+     *
+     * @default ['--deep', '-u']
+     */
+    ncuCommandArgs: string[];
+    /**
+     * Options of generate changelog
+     *
+     * @link https://github.com/soybeanjs/changelog
+     */
+    changelogOptions: Partial<ChangelogOption>;
+    /** The ignore pattern list of git commit verify */
+    gitCommitVerifyIgnores: RegExp[];
+}

package/dist/uno-preset/index.d.ts

@@ -0,0 +1,4 @@
+import { Preset } from '@unocss/core';
+import { Theme } from '@unocss/preset-mini';
+export declare function createPresetYugu(name?: string): Preset<Theme>;
+export default createPresetYugu;

package/dist/uno-preset.d.ts

@@ -0,0 +1,6 @@
+export * from './uno-preset/index.js'
+export {}
+import _default from './uno-preset/index.js'
+export default _default
+export * from './uno-preset/index.js'
+export {}

package/dist/uno-preset.js

@@ -0,0 +1,49 @@
+//#region src/uno-preset/index.ts
+function createPresetYugu(name = "preset-yugu") {
+	return {
+		name,
+		shortcuts: [
+			{
+				"flex-center": "flex justify-center items-center",
+				"flex-x-center": "flex justify-center",
+				"flex-y-center": "flex items-center",
+				"flex-col": "flex flex-col",
+				"flex-col-center": "flex-center flex-col",
+				"flex-col-stretch": "flex-col items-stretch",
+				"i-flex-center": "inline-flex justify-center items-center",
+				"i-flex-x-center": "inline-flex justify-center",
+				"i-flex-y-center": "inline-flex items-center",
+				"i-flex-col": "flex-col inline-flex",
+				"i-flex-col-center": "flex-col i-flex-center",
+				"i-flex-col-stretch": "i-flex-col items-stretch",
+				"flex-1-hidden": "flex-1 overflow-hidden"
+			},
+			{
+				"absolute-lt": "absolute left-0 top-0",
+				"absolute-lb": "absolute left-0 bottom-0",
+				"absolute-rt": "absolute right-0 top-0",
+				"absolute-rb": "absolute right-0 bottom-0",
+				"absolute-tl": "absolute-lt",
+				"absolute-tr": "absolute-rt",
+				"absolute-bl": "absolute-lb",
+				"absolute-br": "absolute-rb",
+				"absolute-center": "absolute-lt flex-center size-full",
+				"fixed-lt": "fixed left-0 top-0",
+				"fixed-lb": "fixed left-0 bottom-0",
+				"fixed-rt": "fixed right-0 top-0",
+				"fixed-rb": "fixed right-0 bottom-0",
+				"fixed-tl": "fixed-lt",
+				"fixed-tr": "fixed-rt",
+				"fixed-bl": "fixed-lb",
+				"fixed-br": "fixed-rb",
+				"fixed-center": "fixed-lt flex-center size-full"
+			},
+			{
+				"nowrap-hidden": "overflow-hidden whitespace-nowrap",
+				"ellipsis-text": "nowrap-hidden text-ellipsis"
+			}
+		]
+	};
+}
+//#endregion
+export { createPresetYugu, createPresetYugu as default };

package/dist/utils/color/constant/index.d.ts

@@ -0,0 +1,2 @@
+export * from './name';
+export * from './palette';

package/dist/utils/color/constant/name.d.ts

@@ -0,0 +1,8 @@
+export declare const colorNames: [hex: string, name: string][];
+/**
+ * Map Of hex color values to color names
+ *
+ * - key: hex value
+ * - value: color name
+ */
+export declare const colorNameMap: Record<string, string>;

package/dist/utils/color/constant/palette.d.ts

@@ -0,0 +1,2 @@
+import { ColorPaletteFamily } from '../types';
+export declare const colorPalettes: ColorPaletteFamily[];

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

@@ -0,0 +1,5 @@
+import { colorPalettes } from './constant';
+export * from './palette';
+export * from './shared';
+export { colorPalettes };
+export * from './types';

package/dist/utils/color/palette/antd.d.ts

@@ -0,0 +1,18 @@
+import { AnyColor } from 'colord';
+import { ColorIndex } from '../types';
+/**
+ * Get AntD palette color by index
+ *
+ * @param color - Color
+ * @param index - The color index of color palette (the main color index is 6)
+ * @returns Hex color
+ */
+export declare function getAntDPaletteColorByIndex(color: AnyColor, index: ColorIndex): string;
+/**
+ * Get AntD color palette
+ *
+ * @param color - Color
+ * @param darkTheme - Dark theme
+ * @param darkThemeMixColor - Dark theme mix color (default: #141414)
+ */
+export declare function getAntDColorPalette(color: AnyColor, darkTheme?: boolean, darkThemeMixColor?: string): string[];

package/dist/utils/color/palette/index.d.ts

@@ -0,0 +1,17 @@
+import { AnyColor } from 'colord';
+import { ColorPaletteNumber } from '../types';
+/**
+ * get color palette by provided color
+ *
+ * @param color
+ * @param recommended whether to get recommended color palette (the provided color may not be the main color)
+ */
+export declare function getColorPalette(color: AnyColor, recommended?: boolean): Map<ColorPaletteNumber, string>;
+/**
+ * get color palette color by number
+ *
+ * @param color the provided color
+ * @param number the color palette number
+ * @param recommended whether to get recommended color palette (the provided color may not be the main color)
+ */
+export declare function getPaletteColorByNumber(color: AnyColor, number: ColorPaletteNumber, recommended?: boolean): string;

package/dist/utils/color/palette/recommend.d.ts

@@ -0,0 +1,20 @@
+import { ColorPaletteFamily, ColorPaletteMatch, ColorPaletteNumber } from '../types';
+/**
+ * get recommended color palette by provided color
+ *
+ * @param color the provided color
+ */
+export declare function getRecommendedColorPalette(color: string): ColorPaletteMatch;
+/**
+ * get recommended palette color by provided color
+ *
+ * @param color the provided color
+ * @param number the color palette number
+ */
+export declare function getRecommendedPaletteColorByNumber(color: string, number: ColorPaletteNumber): string;
+/**
+ * get color palette family by provided color and color name
+ *
+ * @param color the provided color
+ */
+export declare function getRecommendedColorPaletteFamily(color: string): ColorPaletteFamily;

package/dist/utils/color/shared/colord.d.ts

@@ -0,0 +1,38 @@
+import { colord, AnyColor, HslColor } from 'colord';
+export declare function isValidColor(color: AnyColor): boolean;
+export declare function getHex(color: AnyColor): string;
+export declare function getRgb(color: AnyColor): import('colord').RgbaColor;
+export declare function getHsl(color: AnyColor): import('colord').HslaColor;
+export declare function getHsv(color: AnyColor): import('colord').HsvaColor;
+export declare function getDeltaE(color1: AnyColor, color2: AnyColor): number;
+export declare function transformHslToHex(color: HslColor): string;
+/**
+ * Add color alpha
+ *
+ * @param color - Color
+ * @param alpha - Alpha (0 - 1)
+ */
+export declare function addColorAlpha(color: AnyColor, alpha: number): string;
+/**
+ * Mix color
+ *
+ * @param firstColor - First color
+ * @param secondColor - Second color
+ * @param ratio - The ratio of the second color (0 - 1)
+ */
+export declare function mixColor(firstColor: AnyColor, secondColor: AnyColor, ratio: number): string;
+/**
+ * Transform color with opacity to similar color without opacity
+ *
+ * @param color - Color
+ * @param alpha - Alpha (0 - 1)
+ * @param bgColor Background color (usually white or black)
+ */
+export declare function transformColorWithOpacity(color: AnyColor, alpha: number, bgColor?: string): string;
+/**
+ * Is white color
+ *
+ * @param color - Color
+ */
+export declare function isWhiteColor(color: AnyColor): boolean;
+export { colord };

package/dist/utils/color/shared/index.d.ts

@@ -0,0 +1,2 @@
+export * from './colord';
+export * from './name';

package/dist/utils/color/shared/name.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Get color name
+ *
+ * @param color
+ */
+export declare function getColorName(color: string): string;