@cmtlyt/lingshu-toolkit 0.1.0 → 0.1.1

package/dist/{react.js → react/index.js}

@@ -1,5 +1,5 @@
 import { useEffect, useEffectEvent, useMemo, useRef, useState } from "react";
-import { dataHandler, logger, $dt, $t } from "./607.js";
+import { dataHandler, logger, $dt, $t } from "../607.js";
 function useValidData(data, verifyInfo, options) {
     const verifyInfoRef = useRef(verifyInfo);
     const optionsRef = useRef(options);
@@ -82,5 +82,5 @@ function useCounter(initialValue = 0, options = {}) {
         actions
     ];
 }
-export { $dt, $t, defineTransform } from "./607.js";
+export { $dt, $t, defineTransform } from "../607.js";
 export { useControllableValue, useCounter, useValidData };

package/dist/react/use-controllable-value/index.d.ts

@@ -1,4 +1,3 @@
-import type { NotUnion } from '../../shared/types';
 interface UseControllableValueOptions<Ks extends PropertyKey = PropertyKey, P extends Ks | (string & {}) = 'value'> {
     defaultValue: any;
     defaultValuePropName: Ks;
@@ -6,9 +5,11 @@ interface UseControllableValueOptions<Ks extends PropertyKey = PropertyKey, P ex
     trigger: Ks;
 }
 export type PublicUseControllableValueOptions<Ks extends PropertyKey = PropertyKey, P extends Ks | (string & {}) = 'value'> = Partial<UseControllableValueOptions<Ks, P>>;
-type ValueType<T extends Record<PropertyKey, any>, P> = NotUnion<P> extends true ? P extends keyof T ? T[P] : T['value'] : T['value'];
+type ParseDefaultValue<OT extends Record<PropertyKey, any>, O extends PublicUseControllableValueOptions> = O['defaultValuePropName'] extends keyof OT ? OT[O['defaultValuePropName']] : O['defaultValue'];
+type Defaultize<OT extends Record<PropertyKey, any>, P extends keyof OT | (string & {}), O extends PublicUseControllableValueOptions> = P extends keyof OT ? undefined extends OT[P] ? OT[P] & ParseDefaultValue<OT, O> : OT[P] : ParseDefaultValue<OT, O>;
+type ValueType<T extends Record<PropertyKey, any>, O extends PublicUseControllableValueOptions<PropertyKey, any>> = O['valuePropName'] extends keyof T ? Defaultize<T, O['valuePropName'], O> : Defaultize<T, 'value', O>;
 /**
  * 受控组件 value 逻辑切换, 如果传递了 value 则走受控逻辑, 否则走非受控逻辑
  */
-export declare function useControllableValue<T extends Record<PropertyKey, any>, P extends keyof T | (string & {}) = PropertyKey>(props?: T, options?: PublicUseControllableValueOptions<keyof T, P>): [ValueType<T, P>, (value: ValueType<T, P>, ...args: any[]) => void];
+export declare function useControllableValue<T extends Record<PropertyKey, any>, P extends keyof T | (string & {}) = PropertyKey, O extends PublicUseControllableValueOptions<keyof T, P> = PublicUseControllableValueOptions<keyof T, P>>(props?: T, options?: O): [ValueType<T, O>, (value: ValueType<T, O>, ...args: any[]) => void];
 export {};

package/dist/shared/data-handler/tools.js

@@ -0,0 +1,44 @@
+import { logger } from "../logger/index.js";
+function getType(_v) {
+    return Object.prototype.toString.call(_v).slice(8, -1).toLowerCase();
+}
+function typeHandler(type, verifyFn) {
+    return (fullback)=>(_v, actions)=>{
+            if (verifyFn ? verifyFn(_v) : getType(_v) === type) return true;
+            if (null == fullback) return false;
+            let fullbackValue = fullback;
+            if ('function' == typeof fullback) fullbackValue = fullback(_v);
+            actions.transform(fullbackValue);
+        };
+}
+const $t = {
+    notNullable: typeHandler('notNullable', (_v)=>null != _v),
+    string: typeHandler('string'),
+    validString: typeHandler('validString', (_v)=>'string' == typeof _v && _v.length > 0),
+    number: typeHandler('number'),
+    validNumber: typeHandler('validNumber', (_v)=>'number' == typeof _v && !Number.isNaN(_v)),
+    boolean: typeHandler('boolean'),
+    object: typeHandler('object'),
+    array: typeHandler('array'),
+    function: typeHandler('function'),
+    symbol: typeHandler('symbol')
+};
+function defineTransform(dataInfo) {
+    const verifyInfo = {};
+    const keys = Reflect.ownKeys(dataInfo);
+    for(let i = 0, key = keys[i], item = dataInfo[key]; i < keys.length; key = keys[++i], item = dataInfo[key]){
+        if ('function' == typeof item) {
+            verifyInfo[key] = item;
+            continue;
+        }
+        const handler = $t[item];
+        if (!handler) {
+            logger.warn(`${item} is not a valid type`);
+            continue;
+        }
+        verifyInfo[key] = handler();
+    }
+    return verifyInfo;
+}
+const $dt = defineTransform;
+export { $dt, $t, defineTransform };

package/dist/{shared.js → shared/index.js}

@@ -1 +1 @@
-export { $dt, $t, dataHandler, defineTransform, throwError, throwType } from "./607.js";
+export { $dt, $t, dataHandler, defineTransform, throwError, throwType } from "../607.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cmtlyt/lingshu-toolkit",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "type": "module",
   "main": "./dist/shared.js",
   "module": "./dist/shared.js",
@@ -8,20 +8,22 @@
   "exports": {
     ".": {
       "types": "./dist/shared/index.d.ts",
-      "import": "./dist/shared.js"
+      "import": "./dist/shared/index.js"
     },
     "./react": {
       "types": "./dist/react/index.d.ts",
-      "import": "./dist/react.js"
+      "import": "./dist/react/index.js"
     },
     "./react/*": {
+      "types": "./dist/react/*/index.d.ts",
       "import": "./dist/react/*"
     },
     "./shared": {
       "types": "./dist/shared/index.d.ts",
-      "import": "./dist/shared.js"
+      "import": "./dist/shared/index.js"
     },
     "./shared/*": {
+      "types": "./dist/shared/*/index.d.ts",
       "import": "./dist/shared/*"
     }
   },