amotify 0.0.0

package/dist/@comps/Functions/Table/Drag/parts.js

@@ -0,0 +1,359 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DragTable = void 0;
+var _global_1 = require("@global");
+var _atoms_1 = require("@atoms");
+var _functions_1 = require("@functions");
+var useState = React.useState, useEffect = React.useEffect;
+var _1 = require("../_");
+var style_module_scss_1 = __importDefault(require("../style.module.scss"));
+var HeadRow = function (props) {
+    var _a = props.cellStyles, cellStyles = _a === void 0 ? {} : _a, _b = props.cellClassName, cellClassName = _b === void 0 ? '' : _b, cellStylesCallback = props.cellStylesCallback, colLength = props.colLength, head = props.head, rows = props.rows;
+    if (!head)
+        return null;
+    var Cols = [];
+    for (var colIndex = 0; colIndex < colLength; colIndex++) {
+        var col = head[colIndex];
+        var Cell = _1.Comps[col.type == 'th' ? 'TH' : 'TD'];
+        Cols.push(React.createElement(Cell, __assign({}, cellStyles, (0, _1.DefaultCellSystemStyles)({
+            top: true,
+            bottom: !rows.length,
+            left: colIndex == 0,
+            right: colIndex == colLength - 1
+        }), cellStylesCallback ? cellStylesCallback({
+            top: true,
+            bottom: !rows.length,
+            left: colIndex == 0,
+            right: colIndex == colLength - 1,
+            rowIndex: 0,
+            colIndex: colIndex,
+            isBody: false,
+            isHeader: true,
+        }) : {}, { className: [
+                style_module_scss_1.default.Cell,
+                cellClassName,
+                col.className,
+            ].join(' ') }, col)));
+    }
+    return (React.createElement(_1.Comps.Row, { className: [style_module_scss_1.default.Row, style_module_scss_1.default.HeadRow].join(' '), children: Cols }));
+};
+var BodyRows = function (props) {
+    var _a = props.cellStyles, cellStyles = _a === void 0 ? {} : _a, _b = props.cellClassName, cellClassName = _b === void 0 ? '' : _b, cellStylesCallback = props.cellStylesCallback, head = props.head, rows = props.rows, colLength = props.colLength, onOrderChanged = props.onOrderChanged;
+    var _c = __read(useState($.uuidGen()), 1), val_componentID = _c[0];
+    var _d = __read(useState({
+        rows: rows,
+        origin: 0,
+        to: NaN
+    }), 2), val_info = _d[0], set_info = _d[1];
+    var BodyRows = [];
+    val_info.rows.forEach(function (cols, rowIndex) {
+        var Cols = [];
+        {
+            Cols.push(React.createElement(_1.Comps.TH, __assign({ key: 'DragOrigin' }, cellStyles, (0, _1.DefaultCellSystemStyles)({
+                top: rowIndex == 0 && !head,
+                bottom: rowIndex == rows.length - 1,
+                left: true,
+                right: false
+            }), cellStylesCallback ? cellStylesCallback({
+                top: rowIndex == 0 && !head,
+                bottom: rowIndex == rows.length - 1,
+                left: true,
+                right: false,
+                rowIndex: rowIndex,
+                colIndex: 0,
+                isBody: true,
+                isHeader: false,
+            }) : {}, { padding: 0, borderRight: true, className: [
+                    style_module_scss_1.default.Cell,
+                    style_module_scss_1.default.Draggable,
+                    cellClassName
+                ].join(' ') }),
+                React.createElement(_functions_1.Buttons.Button.Clear.R, { className: style_module_scss_1.default.DragableButton, fontColor: '5.translucent', fontSize: '3.paragraph', margin: 'auto', tabIndex: -1, ssSphere: 3, onMouseDown: function (event) {
+                        EffectStart(event, {
+                            id: val_componentID,
+                            index: rowIndex,
+                            rows: val_info.rows,
+                            maxLength: rows.length
+                        });
+                    }, onTouchStart: function (event) {
+                        EffectStart(event, {
+                            id: val_componentID,
+                            index: rowIndex,
+                            rows: val_info.rows,
+                            maxLength: rows.length
+                        });
+                    } },
+                    React.createElement(_atoms_1.FAIcon, { d: 'grip-dots-vertical' }))));
+        }
+        cols.forEach(function (col, colIndex) {
+            col = __assign({}, col);
+            var Cell = _1.Comps[col.type == 'th' ? 'TH' : 'TD'];
+            Cols.push(React.createElement(Cell, __assign({}, cellStyles, (0, _1.DefaultCellSystemStyles)({
+                top: !!head && !head.length,
+                bottom: rowIndex == rows.length - 1,
+                left: false,
+                right: colIndex == colLength - 2
+            }), cellStylesCallback ? cellStylesCallback({
+                top: !!head && !head.length,
+                bottom: rowIndex == rows.length - 1,
+                left: false,
+                right: colIndex == colLength - 2,
+                rowIndex: rowIndex,
+                colIndex: colIndex,
+                isBody: true,
+                isHeader: false,
+            }) : {}, { className: [
+                    style_module_scss_1.default.Cell,
+                    cellClassName,
+                    col.className,
+                ].join(' ') }, col)));
+        });
+        BodyRows.push(React.createElement(_1.Comps.Row, { key: rowIndex, id: 'TableRow-' + val_componentID + '-' + rowIndex, "data-rowId": rowIndex, className: [style_module_scss_1.default.Row, style_module_scss_1.default.BodyRow].join(' '), children: Cols }));
+    });
+    if (!isNaN(val_info.to)) {
+        var origin_1 = val_info.origin, to = val_info.to;
+        var Cols_1 = [];
+        Cols_1.push(React.createElement(_1.Comps.TH, { key: 'dragButton', backgroundColor: 'tcOpLow', padding: 0, borderRight: '2.normal', className: [
+                style_module_scss_1.default.Cell,
+                style_module_scss_1.default.Draggable,
+                cellClassName
+            ].join(' ') },
+            React.createElement(_atoms_1.FAIcon.ArrowRight, { fontColor: 'theme' })));
+        var cols = val_info.rows[origin_1];
+        cols.forEach(function (col, colIndex) {
+            col = __assign({}, col);
+            var Cell = _1.Comps[col.type == 'th' ? 'TH' : 'TD'];
+            Cols_1.push(React.createElement(Cell, __assign({}, cellStyles, (0, _1.DefaultCellSystemStyles)({
+                top: false,
+                bottom: false,
+                left: false,
+                right: false
+            }), cellStylesCallback ? cellStylesCallback({
+                top: false,
+                bottom: false,
+                left: false,
+                right: false,
+                rowIndex: -1,
+                colIndex: -1,
+                isBody: true,
+                isHeader: false,
+            }) : {}, { className: [
+                    style_module_scss_1.default.Cell,
+                    cellClassName,
+                    col.className,
+                ].join(' '), backgroundColor: 'tcOpLow' }, col)));
+        });
+        BodyRows.splice(to, 0, React.createElement(_1.Comps.Row, { key: 'preSet', className: [style_module_scss_1.default.Row, style_module_scss_1.default.Pre].join(' '), children: Cols_1 }));
+    }
+    useEffect(function () {
+        _global_1.useStore.set({
+            key: val_componentID,
+            value: {
+                swap: function (rowIndex, insertIndex) {
+                    if (insertIndex || insertIndex == 0) {
+                        var targetRow = val_info.rows[rowIndex];
+                        var newRows = __spreadArray([], __read(val_info.rows), false);
+                        newRows.splice(rowIndex, 1);
+                        newRows.splice(insertIndex - (rowIndex < insertIndex ? 1 : 0), 0, targetRow);
+                        set_info({
+                            rows: newRows,
+                            origin: 0,
+                            to: NaN
+                        });
+                        onOrderChanged(newRows.map(function (row) { return JSON.parse(row.rowID); }));
+                    }
+                },
+                preSet: function (props) {
+                    var origin = props.origin, index = props.index;
+                    set_info({
+                        rows: val_info.rows,
+                        origin: origin,
+                        to: index
+                    });
+                }
+            }
+        });
+    });
+    useEffect(function () {
+        return function () {
+            _global_1.useStore.delete(val_componentID);
+        };
+    }, []);
+    return (React.createElement(React.Fragment, null, BodyRows));
+};
+var DragTable = function (params) {
+    params.colLength = params.colLength + 1;
+    if (params.head) {
+        params.head = __spreadArray([
+            {
+                children: React.createElement(_functions_1.Buttons.Button.Plain, { ssSphere: 3, fontSize: '3.paragraph', fontColor: 'theme', onMouseOver: function (event) {
+                        _functions_1.Tooltips.open({
+                            parent: event.currentTarget,
+                            padding: [0, 1],
+                            content: React.createElement(_functions_1.Tooltips.Comps.Body, null,
+                                React.createElement(_atoms_1.FAIcon, { d: 'grip-dots-vertical' }),
+                                "\u30DC\u30BF\u30F3\u3092\u30C9\u30E9\u30C3\u30B0\u3057\u3066\u9806\u5E8F\u3092\u5909\u66F4")
+                        });
+                    } },
+                    React.createElement(_atoms_1.FAIcon.QuestionCircle, null)),
+                padding: [0, 1],
+                unitWidth: 4
+            }
+        ], __read(params.head), false);
+    }
+    params.rows = params.rows.map(function (row, rowIndex) {
+        row.rowID = JSON.stringify(row.rowID || rowIndex);
+        return row;
+    });
+    return (React.createElement(_1.Comps.Table, { className: style_module_scss_1.default.Table },
+        React.createElement(HeadRow, __assign({}, params)),
+        React.createElement(BodyRows, __assign({}, params))));
+};
+exports.DragTable = DragTable;
+var EffectStart = function (event, info) {
+    return __awaiter(this, void 0, void 0, function () {
+        var id, index, rows, maxLength;
+        return __generator(this, function (_a) {
+            event.stopPropagation();
+            event.preventDefault();
+            id = info.id, index = info.index, rows = info.rows, maxLength = info.maxLength;
+            $('#TableRow-' + id + '-' + index).addClass(style_module_scss_1.default.DraggerOrigin);
+            $(document)
+                .addEvent({
+                eventID: 'DragMouseMove',
+                eventType: 'mousemove',
+                callback: function (event) { EffectMove(event, info); },
+                option: { passive: false }
+            })
+                .addEvent({
+                eventID: 'DragTouchMove',
+                eventType: 'touchmove',
+                callback: function (event) { EffectMove(event, info); },
+                option: { passive: false }
+            })
+                .addEvent({
+                eventID: 'DragMouseUp',
+                eventType: 'mouseup',
+                callback: function (event) { EffectEnd(event, info); }
+            })
+                .addEvent({
+                eventID: 'DragTouchEnd',
+                eventType: 'touchend',
+                callback: function (event) { EffectEnd(event, info); }
+            });
+            return [2 /*return*/];
+        });
+    });
+};
+var EffectMove = function (event, info) {
+    var id = info.id, maxLength = info.maxLength;
+    var Y = $.getCursor(event).y - $.getScreenSize().scrollY;
+    for (var rowIndex = 0; rowIndex < maxLength; rowIndex++) {
+        var Row = $('#TableRow-' + id + '-' + rowIndex);
+        var _a = Row.position(), rT = _a.top, rB = _a.bottom, rH = _a.height;
+        if (rowIndex == 0 && Y < rT) {
+            info.insertIndex = 0;
+        }
+        else if (rowIndex === maxLength - 1 && rB <= Y) {
+            info.insertIndex = maxLength;
+        }
+        else if (Y >= rT && Y < rB) {
+            info.insertIndex = rowIndex + 1;
+        }
+    }
+    {
+        var index = info.index, insertIndex = info.insertIndex;
+        var component = _global_1.useStore.get(id);
+        if (component && component.preSet)
+            component.preSet({
+                origin: index,
+                index: insertIndex
+            });
+    }
+    event.stopPropagation();
+    event.preventDefault();
+    return false;
+};
+var EffectEnd = function (event, info) {
+    var id = info.id, index = info.index, insertIndex = info.insertIndex;
+    var component = _global_1.useStore.get(id);
+    if (component && component.swap)
+        component.swap(index, insertIndex);
+    $('#TableRow-' + id + '-' + index).removeClass(style_module_scss_1.default.DraggerOrigin);
+    $(document).removeEvent(['DragMouseMove', 'DragTouchMove', 'DragMouseUp', 'DragTouchEnd']);
+};

package/dist/@comps/Functions/Table/Normal/parts.d.ts

@@ -0,0 +1 @@
+export declare const NormalTable: FNC<amotify.fn.Tables.Normal.Params>;

package/dist/@comps/Functions/Table/Normal/parts.js

@@ -0,0 +1,92 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NormalTable = void 0;
+var style_module_scss_1 = __importDefault(require("../style.module.scss"));
+var _1 = require("../_");
+var HeadRow = function (params) {
+    var _a = params.cellStyles, cellStyles = _a === void 0 ? {} : _a, _b = params.cellClassName, cellClassName = _b === void 0 ? '' : _b, cellStylesCallback = params.cellStylesCallback, colLength = params.colLength, head = params.head, rows = params.rows;
+    if (!head)
+        return null;
+    var Cols = [];
+    head.forEach(function (col, colIndex) {
+        var Cell = _1.Comps[col.type == 'th' ? 'TH' : 'TD'];
+        Cols.push(React.createElement(Cell, __assign({}, cellStyles, (0, _1.DefaultCellSystemStyles)({
+            top: true,
+            bottom: !rows.length,
+            left: colIndex == 0,
+            right: colIndex == colLength - 1
+        }), cellStylesCallback ? cellStylesCallback({
+            top: true,
+            bottom: !rows.length,
+            left: colIndex == 0,
+            right: colIndex == colLength - 1,
+            rowIndex: 0,
+            colIndex: colIndex,
+            isBody: false,
+            isHeader: true,
+        }) : {}, { className: [
+                style_module_scss_1.default.Cell,
+                cellClassName,
+                col.className,
+            ].join(' ') }, col)));
+    });
+    return (React.createElement(_1.Comps.Row, { className: [style_module_scss_1.default.Row, style_module_scss_1.default.HeadRow].join(' '), children: Cols }));
+};
+var BodyRows = function (params) {
+    var _a = params.cellStyles, cellStyles = _a === void 0 ? {} : _a, _b = params.cellClassName, cellClassName = _b === void 0 ? '' : _b, cellStylesCallback = params.cellStylesCallback, head = params.head, rows = params.rows, colLength = params.colLength, onRowClick = params.onRowClick;
+    var BodyRows = [];
+    rows.forEach(function (cols, rowIndex) {
+        var Cols = [];
+        cols.forEach(function (col, colIndex) {
+            var Cell = _1.Comps[col.type == 'th' ? 'TH' : 'TD'];
+            Cols.push(React.createElement(Cell, __assign({}, cellStyles, (0, _1.DefaultCellSystemStyles)({
+                top: rowIndex == 0 && !head,
+                bottom: rowIndex == rows.length - 1,
+                left: colIndex == 0,
+                right: colIndex == colLength - 1
+            }), cellStylesCallback ? cellStylesCallback({
+                top: rowIndex == 0 && !head,
+                bottom: rowIndex == rows.length - 1,
+                left: colIndex == 0,
+                right: colIndex == colLength - 1,
+                rowIndex: rowIndex,
+                colIndex: colIndex,
+                isBody: true,
+                isHeader: false,
+            }) : {}, { className: [
+                    style_module_scss_1.default.Cell,
+                    cellClassName,
+                    col.className,
+                ].join(' ') }, col)));
+        });
+        BodyRows.push(React.createElement(_1.Comps.Row, { key: rowIndex, className: [style_module_scss_1.default.Row, style_module_scss_1.default.BodyRow].join(' '), children: Cols, onClick: function (event) {
+                if (onRowClick)
+                    onRowClick(cols.rowID, event);
+            } }));
+    });
+    return (React.createElement(React.Fragment, null, BodyRows));
+};
+var NormalTable = function (params) {
+    params.rows = params.rows.map(function (row, rowIndex) {
+        row.rowID = row.rowID || rowIndex;
+        return row;
+    });
+    return (React.createElement(_1.Comps.Table, { className: style_module_scss_1.default.Table },
+        React.createElement(HeadRow, __assign({}, params)),
+        React.createElement(BodyRows, __assign({}, params))));
+};
+exports.NormalTable = NormalTable;

package/dist/@comps/Functions/Table/_.d.ts

@@ -0,0 +1,9 @@
+export declare const Comps: amotify.fn.Tables.CompsMethods;
+export declare const Table: amotify.fn.Tables.Methods;
+export declare const DefaultCellStyles: (type: amotify.fn.Tables.Types, tone: amotify.fn.Tables.Tones) => amotifyUniStyleParams;
+export declare const DefaultCellSystemStyles: (args: {
+    top: boolean;
+    bottom: boolean;
+    left: boolean;
+    right: boolean;
+}) => amotifyUniStyleParams;

package/dist/@comps/Functions/Table/_.js

@@ -0,0 +1,153 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultCellSystemStyles = exports.DefaultCellStyles = exports.Table = exports.Comps = void 0;
+var _global_1 = require("@global");
+var _atoms_1 = require("@atoms");
+exports.Comps = {
+    Table: function (params) { return (React.createElement("table", __assign({}, _global_1.StyleConverter.ToClassName(params)))); },
+    Head: function (params) { return (React.createElement("thead", __assign({}, _global_1.StyleConverter.ToClassName(params)))); },
+    Body: function (params) { return (React.createElement("tbody", __assign({}, _global_1.StyleConverter.ToClassName(params)))); },
+    Row: function (params) { return (React.createElement("tr", __assign({}, _global_1.StyleConverter.ToClassName(params)))); },
+    TH: function (params) { return (React.createElement("th", __assign({}, _global_1.StyleConverter.ToClassName(params)))); },
+    TD: function (params) { return (React.createElement("td", __assign({}, _global_1.StyleConverter.ToClassName(params)))); },
+    RightIndicator: {
+        type: 'td',
+        unitWidth: 4,
+        // data: '',
+        children: React.createElement(_atoms_1.FAIcon.AngleRight, { fontColor: 'theme', fontSize: '4.thirdTitle' })
+    }
+};
+var parts_1 = require("./Normal/parts");
+var parts_2 = require("./Data/parts");
+var parts_3 = require("./Drag/parts");
+var style_module_scss_1 = __importDefault(require("./style.module.scss"));
+var Wrapper = function (params) {
+    var tone = params.tone, type = params.type;
+    params.tableID = params.tableID || $.uuidGen();
+    tone = tone || 'auto';
+    if (tone == 'auto') {
+        if (type == 'drag') {
+            tone = 'rowBorder';
+        }
+        else {
+            tone = 'border';
+        }
+    }
+    var Params = __assign(__assign(__assign({}, tone != 'plain' ? {
+        backgroundColor: '1.layer.base',
+        borderRadius: '1.tone.primary',
+    } : {}), params), { cellStyles: __assign(__assign({ padding: '3/4', backgroundColor: '1.layer.base', transition: 'short', textAlign: 'center' }, (0, exports.DefaultCellStyles)(type, tone)), params.cellStyles), tone: tone });
+    var _a = _global_1.StyleConverter.ToClassName(Params), className = _a.className, freeCSS = _a.style, others = __rest(_a, ["className", "style"]);
+    var ClassName = [
+        className,
+        style_module_scss_1.default.Wrap,
+        style_module_scss_1.default['TableType_' + type],
+        style_module_scss_1.default['RowClickable_' + !!params.onRowClick]
+    ].join(' ');
+    var TableComponent = {
+        'normal': parts_1.NormalTable,
+        'data': parts_2.DataTable,
+        'drag': parts_3.DragTable,
+        'spread': ''
+    }[type];
+    return (React.createElement(_atoms_1.Box, { className: ClassName, style: freeCSS },
+        React.createElement(TableComponent, __assign({}, others))));
+};
+var DataComponent = function (props) { return (React.createElement(Wrapper, __assign({ type: 'data' }, props))); };
+Object.entries(parts_2.DataFNs).forEach(function (_a) {
+    var _b = __read(_a, 2), key = _b[0], value = _b[1];
+    DataComponent[key] = value;
+});
+Object.entries(parts_2.DataComps).forEach(function (_a) {
+    var _b = __read(_a, 2), key = _b[0], value = _b[1];
+    DataComponent[key] = value;
+});
+exports.Table = {
+    Normal: function (props) { return (React.createElement(Wrapper, __assign({ type: 'normal' }, props))); },
+    Data: DataComponent,
+    Drag: function (props) { return (React.createElement(Wrapper, __assign({ type: 'drag' }, props))); },
+    Spread: function () { return (React.createElement(React.Fragment, null, "Table.Spread ( in Progress )")); },
+    Comps: exports.Comps
+};
+var DefaultCellStyles = function (type, tone) {
+    if (tone == 'plain')
+        return {};
+    var Styles = {};
+    if (type == 'drag') {
+        Styles.padding = 1;
+    }
+    if (['border', 'rowBorder', 'cellBorder'].includes(tone)) {
+        Styles.borderBottom = '2.normal';
+    }
+    if (['border', 'cellBorder'].includes(tone)) {
+        Styles.borderRight = '2.normal';
+    }
+    return Styles;
+};
+exports.DefaultCellStyles = DefaultCellStyles;
+var DefaultCellSystemStyles = function (args) {
+    var Styles = {};
+    if (args.right) {
+        Styles.borderRight = 'unset';
+    }
+    if (args.top) {
+        if (args.left) {
+            Styles.borderTopLeftRadius = 'inherit';
+        }
+        if (args.right) {
+            Styles.borderTopRightRadius = 'inherit';
+        }
+    }
+    if (args.bottom) {
+        Styles.borderBottom = 'unset';
+        if (args.left) {
+            Styles.borderBottomLeftRadius = 'inherit';
+        }
+        if (args.right) {
+            Styles.borderBottomRightRadius = 'inherit';
+        }
+    }
+    return Styles;
+};
+exports.DefaultCellSystemStyles = DefaultCellSystemStyles;

package/dist/@comps/Functions/Tooltips/parts.d.ts

@@ -0,0 +1,2 @@
+declare const Tooltips: amotify.fn.Tooltips.Methods;
+export { Tooltips };