ados-rcm 1.0.88 → 1.0.89

package/dist/AModule/AComponents/ATable/ATable.d.ts

@@ -1,23 +1,3 @@
-/**
- * ATable
- *
- * Notice 1 : Defs Explanation
- * - Keys of defs are used as each columns.
- * - defaultDef is used as default for each columns, and will not be rendered.
- * - def is calculated as {...defaultDef, ...def}.
- *
- * Notice 2 : Select and Check
- * - Select and Check are different. not like ATree. careful.
- *
- * Notice 3 : entireItems and pagedItems
- * - pagedItems is the items to be rendered.
- * - pagedItems can be provided directly, or it can be calculated from entireItems.
- * - entireItems is the entire items, and will be filtered, sorted, and paged to become the pagedItems.
- *
- *
- * Todo 1 : Defs is declared as type. it would be better to declare as interface, but I couldn't find the way.
- *
- */
 import React from 'react';
 import { TUseValues } from '../../AHooks/useValues';
 import { TCanCallback } from '../../AUtils/cbF';
@@ -379,6 +359,12 @@ export interface IATableProps<T extends IItem> {
      * Description : defs of ATable
      */
     defs: TATableDefs<T>;
+    /**
+     * pk? : keyof T | (keyof T)[]
+     *
+     * Description : pk of ATable
+     */
+    pk?: keyof T | (keyof T)[];
     /**
      * defaultDef? : IATableDef<T>
      *

package/dist/AModule/AComponents/ATable/ATableBody.d.ts

@@ -5,6 +5,7 @@ import { IItem } from '../../AUtils/objF';
 import { IATablePagination, IATableSortation, IATableTRProps, TATableDefs, TATableFilteration } from './ATable';
 interface IATableBodyProps<T extends IItem> {
     defs: TATableDefs<T>;
+    isEqual: (a: T, b: T) => boolean;
     rProps?: TCanCallback<IATableTRProps<T>, React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>>;
     useSelect?: TUseValues<T[]>;
     isTableDisabled?: boolean;

package/dist/AModule/AComponents/ATree/ATree.d.ts

@@ -59,6 +59,12 @@ export interface IATreeAction {
     collapseAll: () => void;
 }
 export interface IATreeProps<T extends IATreeItem<T>> extends IABaseProps {
+    /**
+     * pk? : keyof T | (keyof T)[]
+     *
+     * Description : pk of ATree. if pk is set, it will be used as key of item. if not, index will be used.
+     */
+    pk?: keyof T | (keyof T)[];
     /**
      * ItemRenderer? : (props: IATreeItemProps<T>) => React.ReactNode
      *

package/dist/AModule/AComponents/ATree/ATreeItem.d.ts

@@ -1,9 +1,10 @@
 import React from 'react';
-import { TIcons } from '../AIcon/AIcon';
 import { TUseValues } from '../../AHooks/useValues';
-import { IATreeItem, IATreeSearchResult } from './ATree';
+import { TIcons } from '../AIcon/AIcon';
 import { Resources } from '../AResource/AResource';
+import { IATreeItem, IATreeSearchResult } from './ATree';
 export interface IATreeItemProps<T> {
+    isEqual: (a: T, b: T) => boolean;
     item: T;
     selectDisabled?: (item: T) => boolean | string | undefined;
     isParentDisabled?: boolean;

package/dist/AModule/AComponents/ATree/ATreeSearch.d.ts

@@ -1,6 +1,7 @@
 import { IATreeItem, IATreeSearchResult } from './ATree';
 import { Resources } from '../AResource/AResource';
 interface IATreeSearchProps<T extends IATreeItem<T>> {
+    isEqual: (a: T, b: T) => boolean;
     searchResult: IATreeSearchResult<T> | undefined;
     initSearch: (inputValue: string) => void;
     searchUp: () => void;

package/dist/AModule/AUtils/objF.d.ts

@@ -4,19 +4,16 @@ export interface IObject {
     [key: TIdx]: any;
 }
 export interface IItem extends IObject {
-    idx?: TIdx;
 }
-declare function equal<T extends IItem>(a: T, b: T): boolean;
 export declare const objF: {
-    equal: typeof equal;
-    parse: <T>(value: string) => T | undefined;
+    equal: <T extends IObject>(a: T, b: T) => boolean;
+    parse: <T_1>(value: string) => T_1 | undefined;
     stringify: (value: any, indent?: number | string) => string;
-    keys: <T_1 extends IObject>(obj: T_1) => (keyof T_1)[];
-    values: <T_2 extends IObject>(obj: T_2) => T_2[keyof T_2][];
-    hasKey: <T_3 extends IObject>(obj: T_3, key: string | number | symbol) => key is keyof T_3;
-    map: <T_4 extends IObject, U>(obj: T_4, fn: (keyValue: [keyof T_4, T_4[keyof T_4]], idx: number) => U) => U[];
-    some: <T_5 extends IObject>(obj: T_5, fn: (key: keyof T_5, value: T_5[keyof T_5]) => any) => boolean;
-    find: <T_6 extends IObject>(obj: T_6, fn: (key: keyof T_6, value: T_6[keyof T_6]) => any) => [string, any] | undefined;
+    keys: <T_2 extends IObject>(obj: T_2) => (keyof T_2)[];
+    values: <T_3 extends IObject>(obj: T_3) => T_3[keyof T_3][];
+    hasKey: <T_4 extends IObject>(obj: T_4, key: string | number | symbol) => key is keyof T_4;
+    map: <T_5 extends IObject, U>(obj: T_5, fn: (keyValue: [keyof T_5, T_5[keyof T_5]], idx: number) => U) => U[];
+    some: <T_6 extends IObject>(obj: T_6, fn: (key: keyof T_6, value: T_6[keyof T_6]) => any) => boolean;
+    find: <T_7 extends IObject>(obj: T_7, fn: (key: keyof T_7, value: T_7[keyof T_7]) => any) => [string, any] | undefined;
     isReactNode: (value: any) => value is React.ReactNode;
 };
-export {};

package/dist/AModule/AUtils/treeF.d.ts

@@ -1,21 +1,18 @@
-import { TIdx } from '../AComponents/ATypes/ATypes';
 import { IATreeItem } from '../AComponents/ATree/ATree';
-import { IItem } from './objF';
-declare function equal<T extends IItem>(a: T, b: T): boolean;
+import { TIdx } from '../AComponents/ATypes/ATypes';
 declare function find<T extends IATreeItem<T>>(items: T[] | T, predicate: (item: T, idx?: TIdx) => any): T | undefined;
 declare function forEach<T extends IATreeItem<T>>(items: T[] | T, callback: (item: T, idx?: TIdx) => void): void;
 declare function map<T extends IATreeItem<T>, R>(items: T[] | T, callback: (item: T, idx?: TIdx) => R): R[];
 declare function every<T extends IATreeItem<T>>(items: T[] | T, predicate: (item: T, idx?: TIdx) => boolean): boolean;
 declare function filter<T extends IATreeItem<T>>(items: T[] | T, predicate: (item: T, idx?: TIdx) => boolean): T[];
 declare function length<T extends IATreeItem<T>>(items: T[] | T): number;
-declare function replace<T extends IATreeItem<T>>(items: T[] | T, srcItem: T, dstItem: T): T[] | null;
+declare function replace<T extends IATreeItem<T>>(items: T[] | T, srcItem: T, dstItem: T, isEqual: (a: T, b: T) => boolean): T[] | null;
 export declare const treeF: {
     find: typeof find;
     forEach: typeof forEach;
     map: typeof map;
     every: typeof every;
     filter: typeof filter;
-    equal: typeof equal;
     length: typeof length;
     replace: typeof replace;
 };