xjs-common 13.0.0-alpha.1 → 13.0.0-alpha.2

package/README.md

@@ -141,7 +141,7 @@ class Cls_A implements If_A {
     id: number;
     @DType.string
     strA: string;
-    @DType.recursive(Cls_B)
+    @DType.object(Cls_B)
     objA: If_B;
     p: number;
     constructor(substance?: If_A) { Object.assign(this, substance); }

package/build/func/decorator/d-type.d.ts

@@ -1,12 +1,42 @@
 import { Ctor, Type } from "../../const/types";
 export declare const smbl_tm: unique symbol;
 export interface TypeDesc {
+    /** express primitive type or `object` listed in {@link Type}. */
     t?: Type;
+    /** express required. */
     req?: boolean;
+    /** type description of each value in an array. */
     ary?: TypeDesc;
+    /** express class of the property decorated with {@link DType}. */
+    cls?: Ctor;
+    /** type description of each value in a record object. */
     rcd?: TypeDesc;
-    obj?: Ctor;
 }
+type BasicTypeDesc = TypeDesc & {
+    ary?: never;
+    obj?: never;
+    rec?: never;
+    rcd?: never;
+};
+type ArrayTypeDesc = TypeDesc & {
+    t?: never;
+    obj?: never;
+    rec?: never;
+    rcd?: never;
+};
+type ClassTypeDesc = TypeDesc & {
+    t?: never;
+    ary?: never;
+    rec?: never;
+    rcd?: never;
+};
+type RecordTypeDesc = TypeDesc & {
+    t?: never;
+    arys?: never;
+    obj?: never;
+    rec?: never;
+};
+type AnyTypeDesc = BasicTypeDesc | ArrayTypeDesc | ClassTypeDesc | RecordTypeDesc;
 export interface TypeMap {
     [k: string]: TypeDesc;
 }
@@ -15,13 +45,29 @@ export interface TypeMap {
  * and to be cropped by {@link UObj.crop}.
  */
 export declare namespace DType {
+    /** express `string` property. */
     function string(target: Object, propKey: string): void;
+    /** express `number` property. */
     function number(target: Object, propKey: string): void;
+    /** express `boolean` property. */
     function boolean(target: Object, propKey: string): void;
+    /** express required property. */
     function required(target: Object, propKey: string): void;
-    function array(elmDesc?: TypeDesc | Ctor): (target: Object, propKey: string) => void;
-    /** NOTE: this may allow array type because array is essentialy object type has properties. */
-    function record(elmDesc?: TypeDesc | Ctor): (target: Object, propKey: string) => void;
-    function recursive(ctor: Ctor): (target: Object, propKey: string) => void;
+    /**
+     * express array.
+     * @param elmDesc {@link TypeDesc} or class constructor type.
+     */
+    function array(elmDesc?: AnyTypeDesc | Ctor): (target: Object, propKey: string) => void;
+    /**
+     * express record object. note that this may allow array type because array is essentialy object type has properties.
+     * @param elmDesc {@link TypeDesc} or class constructor type.
+     */
+    function record(elmDesc?: AnyTypeDesc | Ctor): (target: Object, propKey: string) => void;
+    /**
+     * express an object which has properties that specified class express with {@link DType}.
+     * @param ctor class constructor type.
+     */
+    function object(ctor: Ctor): (target: Object, propKey: string) => void;
     function keep(target: Object, propKey: string): void;
 }
+export {};

package/build/func/decorator/d-type.js

@@ -9,14 +9,17 @@ export const smbl_tm = Symbol.for("xjs:typeMap");
  */
 export var DType;
 (function (DType) {
+    /** express `string` property. */
     function string(target, propKey) {
         setTypeDesc(target, propKey, Type.string);
     }
     DType.string = string;
+    /** express `number` property. */
     function number(target, propKey) {
         setTypeDesc(target, propKey, Type.number);
     }
     DType.number = number;
+    /** express `boolean` property. */
     function boolean(target, propKey) {
         setTypeDesc(target, propKey, Type.boolean);
     }
@@ -28,33 +31,45 @@ export var DType;
             td.t = t;
         });
     }
+    /** express required property. */
     function required(target, propKey) {
         setDesc(target, propKey, (td) => td.req = true);
     }
     DType.required = required;
+    /**
+     * express array.
+     * @param elmDesc {@link TypeDesc} or class constructor type.
+     */
     function array(elmDesc = {}) {
-        return (target, propKey) => setDesc(target, propKey, (td) => UType.isFunction(elmDesc) ? td.ary = { obj: elmDesc } : td.ary = elmDesc);
+        return (target, propKey) => setDesc(target, propKey, (td) => UType.isFunction(elmDesc) ? td.ary = { cls: elmDesc } : td.ary = elmDesc);
     }
     DType.array = array;
-    /** NOTE: this may allow array type because array is essentialy object type has properties. */
+    /**
+     * express record object. note that this may allow array type because array is essentialy object type has properties.
+     * @param elmDesc {@link TypeDesc} or class constructor type.
+     */
     function record(elmDesc = {}) {
-        return (target, propKey) => setDesc(target, propKey, (td) => UType.isFunction(elmDesc) ? td.rcd = { obj: elmDesc } : td.rcd = elmDesc);
+        return (target, propKey) => setDesc(target, propKey, (td) => UType.isFunction(elmDesc) ? td.rcd = { cls: elmDesc } : td.rcd = elmDesc);
     }
     DType.record = record;
-    function recursive(ctor) {
-        return (target, propKey) => setDesc(target, propKey, (td) => td.obj = ctor);
+    /**
+     * express an object which has properties that specified class express with {@link DType}.
+     * @param ctor class constructor type.
+     */
+    function object(ctor) {
+        return (target, propKey) => setDesc(target, propKey, (td) => td.cls = ctor);
     }
-    DType.recursive = recursive;
+    DType.object = object;
     function keep(target, propKey) {
         setDesc(target, propKey, (_) => { });
     }
     DType.keep = keep;
     function setDesc(target, propKey, setter) {
         const map = target[smbl_tm] ? Object.assign({}, target[smbl_tm]) : {};
-        map[propKey] ??= { t: null, req: false, obj: null, ary: null, rcd: null };
+        map[propKey] ??= { t: null, req: false, cls: null, ary: null, rcd: null };
         const td = map[propKey];
         setter(td);
-        const structualDescs = [[td.ary, "array"], [td.obj, "recursive"], [td.rcd, "record"]].filter(e => e[0]);
+        const structualDescs = [[td.ary, "array"], [td.cls, "class"], [td.rcd, "record"]].filter(e => e[0]);
         if (structualDescs.length > 0) {
             let ex1 = null, ex2 = null;
             if (td.t) {

package/build/func/u-obj.d.ts

@@ -17,7 +17,7 @@ export declare namespace UObj {
     function crop<T extends NormalRecord>(o: T, keys: (keyof T)[], removeKeys?: boolean): Partial<T>;
     /**
      * crop properties that is not decorated with {@link DType}. the properties will be removed with `delete` operator.
-     * this treats constructual decorator such as {@link DType.recursive} recursively.
+     * this treats constructual decorator such as {@link DType.object} recursively.
      * @param o object whose properties to be removed. if this is class object decorated with {@link DType}, it can omits `ctor` parameter.
      * @param ctor class constructor type whose properties are decorated with {@link DType}. **NOTE** that need to have public constructor without any parameter.
      */

package/build/func/u-obj.js

@@ -28,10 +28,10 @@ export var UObj;
             return removeKeys ? o : {};
         Object.keys(o).filter(k => {
             if (tm && tm[k] && o[k]) {
-                if (tm[k].obj)
-                    crop(o[k], tm[k]?.obj);
+                if (tm[k].cls)
+                    crop(o[k], tm[k]?.cls);
                 else {
-                    const vCtor = tm[k].ary?.obj ?? tm[k].rcd?.obj;
+                    const vCtor = tm[k].ary?.cls ?? tm[k].rcd?.cls;
                     Object.values(o[k]).forEach(v => crop(v, vCtor));
                 }
             }

package/build/func/u-type.js

@@ -53,8 +53,8 @@ export var UType;
         if (td.rcd)
             return UType.isObject(prop)
                 ? Object.entries(prop).flatMap(e => validateProp(e[0], e[1], td.rcd)).map(joinKey) : [k];
-        if (td.obj)
-            return validate(prop, td.obj).flatMap(joinKey);
+        if (td.cls)
+            return validate(prop, td.cls).flatMap(joinKey);
         return [];
     }
     function takeAsArray(v) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xjs-common",
-  "version": "13.0.0-alpha.1",
+  "version": "13.0.0-alpha.2",
   "description": "library modules for typescript that bundled general-purpose implementations.",
   "repository": {
     "type": "git",