amotify 0.0.0

package/dist/@comps/Functions/Input/core.js

@@ -0,0 +1,324 @@
+"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.SubmitForm = exports.ValidationCheck = exports.CommonEffects = exports.BoxWrapper = void 0;
+var _global_1 = require("@global");
+var useEffect = React.useEffect, useState = React.useState, useRef = React.useRef;
+var _atoms_1 = require("@atoms");
+var _mols_1 = require("@mols");
+var _functions_1 = require("@functions");
+var style_module_scss_1 = __importDefault(require("./style.module.scss"));
+var BoxWrapper = function (props) {
+    var children = props.children, val_status = props.val_status, set_status = props.set_status, val_validate = props.val_validate, params = props.params;
+    var clearButton = params.clearButton, rightIcon = params.rightIcon, leftIcon = params.leftIcon, wrapStyles = params.wrapStyles;
+    if (val_status.eventType == 'init' && !params.checkValidationAtFirst)
+        val_validate.notice = [];
+    return (React.createElement(_atoms_1.Box, __assign({ position: 'relative' }, wrapStyles, { id: 'BoxWrapper-' + val_status.componentID }),
+        React.createElement(_atoms_1.Flex, { flexWrap: false },
+            params.leftIndicator,
+            React.createElement(_atoms_1.Flex, { position: 'relative', flexSizing: 'auto' },
+                leftIcon,
+                children,
+                clearButton && !!val_status.dataValue ? React.createElement(_functions_1.Buttons.Button.Normal.R, { ssSphere: 2, flexCenter: true, fontColor: '5.translucent', ssEffectsOnActive: ['ripple.theme'], position: 'absolute', right: 1, top: '50%', freeCSS: {
+                        zIndex: 3
+                    }, className: style_module_scss_1.default.IndicatorIcon, onClick: function () {
+                        set_status(__assign(__assign({}, val_status), { dataValue: '', formatValue: '', eventType: 'update', eventID: $.uuidGen() }));
+                    } },
+                    React.createElement(_atoms_1.FAIcon.Times, null)) : rightIcon),
+            params.rightIndicator),
+        React.createElement(GenNotices, { notice: val_validate.notice, val_status: val_status })));
+};
+exports.BoxWrapper = BoxWrapper;
+var GenNotices = function (params) {
+    var notice = params.notice, val_status = params.val_status;
+    var componentID = val_status.componentID, eventType = val_status.eventType;
+    $.interval.clear('NoticeTimer-' + componentID);
+    $.interval.clear('NoticeTimerClose-' + componentID);
+    var parentID = 'notice-' + params.val_status.componentID;
+    var tipsID = 'notice-tips-' + params.val_status.componentID;
+    if (!notice.length) {
+        _functions_1.Tooltips.close(tipsID);
+        return null;
+    }
+    var Notices = notice.map(function (cell) {
+        var type = cell.type, label = cell.label;
+        return React.createElement(_mols_1.Row.Left, { gap: 0, borderRadius: '2.tone.secondary' },
+            React.createElement(_atoms_1.FAIcon, { flexCenter: true, fontSize: '3.paragraph', fontColor: {
+                    'invalid': 'nega',
+                    'warn': 'warn',
+                    'valid': 'posi',
+                }[type], d: {
+                    'invalid': 'times',
+                    'warn': 'exclamation',
+                    'valid': 'check'
+                }[type] }),
+            React.createElement(_atoms_1.Box, { fontColor: 'white' }, label));
+    });
+    $.interval.standBy('NoticeTimer-' + componentID, 350, function () {
+        _functions_1.Tooltips.open({
+            tipsID: tipsID,
+            parent: '#' + parentID,
+            padding: ['1/2', 0],
+            content: React.createElement(_functions_1.Tooltips.Comps.Body, { padding: ['1/2', '2/3'], fontSize: '1.mini', position: 'relative' },
+                React.createElement(_atoms_1.Box, { position: 'absolute', unitHeight: 1, unitWidth: 1, left: 1, backgroundColor: 'dark', freeCSS: {
+                        zIndex: 1,
+                        transform: 'rotate(45deg)',
+                        top: -6
+                    } }),
+                React.createElement(_mols_1.Column, { gap: '1/3', position: 'relative', freeCSS: {
+                        zIndex: 2
+                    }, backgroundColor: 'inherit' }, Notices))
+        });
+        $.interval.standBy('NoticeTimerClose-' + componentID, 7500, function () {
+            _functions_1.Tooltips.close(tipsID);
+        });
+    });
+    return (React.createElement(_atoms_1.Box, { className: style_module_scss_1.default.Notices, id: parentID }));
+};
+var CommonEffects = function (props) {
+    var type = props.type, params = props.params, val_status = props.val_status, set_status = props.set_status, ExtraOverrideParams = props.ExtraOverrideParams, ExtraStoreParams = props.ExtraStoreParams, val_validate = props.val_validate, set_validate = props.set_validate, DefaultValidation = props.DefaultValidation, onUpdateValue = props.onUpdateValue, onUpdateValidValue = props.onUpdateValidValue;
+    var componentID = val_status.componentID;
+    var _a = __read(useState($.uuidGen()), 2), val_refresh = _a[0], set_refresh = _a[1];
+    useEffect(function () {
+        _global_1.useStore.update({
+            key: componentID,
+            value: __assign({ ResolveRefresh: null, Refresh: function () {
+                    return new Promise(function (res, rej) {
+                        _global_1.useStore.get(componentID).ResolveRefresh = res;
+                        set_refresh($.uuidGen());
+                    });
+                }, GenNotice: function (props) {
+                    var ok = props.ok, notice = props.notice;
+                    set_validate({ ok: ok, notice: notice });
+                } }, ExtraStoreParams)
+        });
+        return function () {
+            _global_1.useStore.delete(componentID);
+        };
+    }, []);
+    var mounted = useRef(false);
+    useEffect(function () {
+        if (mounted.current) {
+            set_status(__assign(__assign({}, val_status), { eventType: 'refresh', eventID: $.uuidGen() }));
+        }
+        else {
+            mounted.current = true;
+        }
+    }, [val_refresh]);
+    useEffect(function () {
+        params.value = val_status.dataValue;
+        $.interval.clear('ValidationTimer-' + componentID);
+        (0, exports.ValidationCheck)({
+            val_status: val_status,
+            set_validate: set_validate,
+            DefaultValidation: DefaultValidation,
+            params: params
+        });
+    }, [val_status.eventID]);
+    (function () {
+        var override = params.override;
+        if (override == 'never')
+            return;
+        if (override == 'beforeModified') {
+            if (!['init', 'override'].includes(val_status.eventType))
+                return;
+        }
+        var component = _global_1.useStore.get(val_status.componentID);
+        if (!component)
+            return;
+        if (params.value != val_status.dataValue &&
+            params.statusID != component.statusID) {
+            set_status(__assign(__assign(__assign(__assign({}, val_status), { dataValue: params.value }), ExtraOverrideParams), { eventType: 'override', eventID: $.uuidGen() }));
+        }
+        component.statusID = params.statusID;
+    })();
+    useEffect(function () {
+        var componentID = val_status.componentID, eventType = val_status.eventType, dataValue = val_status.dataValue;
+        var Value = dataValue;
+        if (type == 'list') {
+            Value = dataValue.map(function (value) { return JSON.parse(value); });
+        }
+        else if (type == 'select') {
+            Value = JSON.parse(dataValue);
+        }
+        else if (type == 'file') {
+            _global_1.useStore.update({
+                key: componentID,
+                value: {
+                    Files: val_status.dataValue
+                }
+            });
+        }
+        if (eventType == 'refresh') {
+            _global_1.useStore.get(componentID).ResolveRefresh(null);
+        }
+        if (eventType == 'update') {
+            if (onUpdateValue)
+                onUpdateValue({
+                    componentID: componentID,
+                    value: Value,
+                    storeData: _global_1.useStore.get(componentID),
+                    eventType: eventType
+                });
+            if (val_validate.ok && $.is.exist(Value)) {
+                if (onUpdateValidValue)
+                    onUpdateValidValue({
+                        componentID: componentID,
+                        value: Value,
+                        storeData: _global_1.useStore.get(componentID),
+                        eventType: eventType
+                    });
+            }
+        }
+    }, [val_validate]);
+};
+exports.CommonEffects = CommonEffects;
+var ValidationCheck = function (props) {
+    var val_status = props.val_status, params = props.params, set_validate = props.set_validate, DefaultValidation = props.DefaultValidation;
+    var result = DefaultValidation({
+        value: val_status.dataValue,
+        params: params
+    });
+    if (!result.ok) {
+        set_validate(result);
+        return;
+    }
+    var sysDefaultNotice = result.notice;
+    var FN = function () { return __awaiter(void 0, void 0, void 0, function () {
+        var result;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (!params.onValidate)
+                        return [2 /*return*/];
+                    return [4 /*yield*/, params.onValidate({
+                            value: val_status.dataValue,
+                            eventType: val_status.eventType,
+                            props: props
+                        })];
+                case 1:
+                    result = _a.sent();
+                    if (!result.ok) {
+                        set_validate({
+                            ok: false,
+                            notice: __spreadArray(__spreadArray([], __read(sysDefaultNotice), false), __read(result.notice), false)
+                        });
+                        return [2 /*return*/];
+                    }
+                    set_validate({
+                        ok: true,
+                        notice: __spreadArray(__spreadArray([], __read(sysDefaultNotice), false), __read(result.notice), false)
+                    });
+                    return [2 /*return*/];
+            }
+        });
+    }); };
+    if (params.onValidate) {
+        if (val_status.eventType == 'refresh') {
+            FN();
+        }
+        else {
+            $.interval.standBy('ValidationTimer-' + val_status.componentID, 450, FN);
+        }
+    }
+    else {
+        set_validate({
+            ok: true,
+            notice: sysDefaultNotice
+        });
+    }
+};
+exports.ValidationCheck = ValidationCheck;
+var SubmitForm = function (event) {
+    var input = event.target;
+    var _a = input.dataset, form = _a.form, formName = _a.formName;
+    form = formName || form;
+    var complete = false;
+    var Button = $("[data-form-submit-button=\"".concat(form, "\"]"))[0];
+    if (!Button)
+        return complete;
+    var gestures = Button.dataset.sdfike || '';
+    var key = event.key;
+    var auxKey = event.ctrlKey || event.metaKey;
+    if ((key == 'Enter' && (gestures.includes('enter') || (gestures.includes('auxEnter') && auxKey))) || (key == ' ' && gestures.includes('space'))) {
+        Button.click();
+        event.preventDefault();
+        complete = true;
+    }
+    return complete;
+};
+exports.SubmitForm = SubmitForm;

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

@@ -0,0 +1,3 @@
+export declare const Inputs: {
+    TextInput: (params: any) => JSX.Element;
+};

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

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Inputs = void 0;
+var text_1 = require("./text");
+exports.Inputs = {
+    TextInput: text_1.TextInput
+};

package/dist/@comps/Functions/Inputs/text.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="react" />
+declare global {
+    namespace Inputs {
+        type ToneTypes = 'normal' | 'cloud' | 'bottomBorder' | 'plain';
+        namespace Text {
+            type Params = any & React.DetailedHTMLProps<React.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement> & {
+                tone?: ToneTypes;
+            };
+        }
+    }
+}
+export declare const TextInput: (params: Inputs.Text.Params) => JSX.Element;

package/dist/@comps/Functions/Inputs/text.js

@@ -0,0 +1,46 @@
+"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.TextInput = void 0;
+var _global_1 = require("@global");
+var style_module_scss_1 = __importDefault(require("./style.module.scss"));
+var ToneStyles = {
+    common: {
+        padding: '3/4',
+        borderRadius: '1.tone.primary',
+        transition: 'middle',
+        boxShadow: 0,
+        className: style_module_scss_1.default.Focus
+    },
+    border: {
+        border: true,
+    },
+    cloud: {
+        border: '1.thin',
+        backgroundColor: 'cloud'
+    },
+    bottomBorder: {
+        borderRadius: 0,
+        backgroundColor: 'cloud',
+        borderBottom: true,
+    },
+    plain: {},
+};
+var TextInput = function (params) {
+    params = __assign(__assign(__assign({}, ToneStyles.common), ToneStyles.bottomBorder), params);
+    return (React.createElement("input", __assign({ type: "text", placeholder: 'fvdgsbsfgdvs' }, _global_1.StyleConverter.ToClassName(params))));
+};
+exports.TextInput = TextInput;

package/dist/@comps/Functions/Layout/PageNotFound.d.ts

@@ -0,0 +1 @@
+export declare const PageNotFound: FNC<{}>;

package/dist/@comps/Functions/Layout/PageNotFound.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PageNotFound = void 0;
+var _atoms_1 = require("@atoms");
+var _mols_1 = require("@mols");
+var _functions_1 = require("@functions");
+var PageNotFound = function () {
+    var href = location.href;
+    return (React.createElement(_mols_1.Row.Center, { padding: [4, 1] },
+        React.createElement(_mols_1.Column, { ssCardBox: true, gap: 2, padding: [3, 2], textAlign: 'center', width: 1, freeCSS: {
+                maxWidth: 12 * 30
+            } },
+            React.createElement(_atoms_1.FAIcon.LinkSlash, { fontColor: 'theme', iconFamily: 'classic', isDuotoneIcon: true, freeCSS: {
+                    fontSize: '3rem'
+                } }),
+            React.createElement(_atoms_1.Box, null,
+                React.createElement(_mols_1.Text.Paragraph, null, "\u3053\u306E\u30DA\u30FC\u30B8\u306F\u3054\u5229\u7528\u3044\u305F\u3060\u3051\u307E\u305B\u3093\u3002"),
+                React.createElement(_mols_1.Text.Supplement, { fontColor: '3.blur' }, "\u5165\u529B\u3055\u308C\u305F\u30EA\u30F3\u30AF\u306E\u30DA\u30FC\u30B8\u306F\u5B58\u5728\u3057\u307E\u305B\u3093\u3067\u3057\u305F\u3002")),
+            React.createElement(_mols_1.Column, null,
+                React.createElement(_mols_1.Text.Normal, { textAlign: 'left', ssCardBox: 'cloud', isBoldFont: true, padding: 1 },
+                    "\u30FB\u30EA\u30F3\u30AF\u304C\u6B63\u3057\u3044\u304B",
+                    React.createElement(_atoms_1.Box, { margin: ['1/2', 0], borderBottom: true }),
+                    "\u30FB\u30EA\u30F3\u30AF\u306E\u6709\u52B9\u671F\u9650",
+                    React.createElement(_atoms_1.Box, { margin: ['1/2', 0], borderBottom: true }),
+                    "\u30FB\u30A2\u30AF\u30BB\u30B9\u6A29\u9650\u7B49\u304C\u6B63\u3057\u3044\u304B"),
+                "\u306A\u3069\u3092\u3082\u3046\u4E00\u5EA6\u78BA\u8A8D\u3057\u3066\u304F\u3060\u3055\u3044\u3002"),
+            React.createElement(_functions_1.Buttons.Anchor.Link, { newTab: true, href: href }, href),
+            React.createElement(_functions_1.Buttons.Anchor.BorderToFill.R, { href: '/', width: 1, children: 'ホームに戻る' }))));
+};
+exports.PageNotFound = PageNotFound;

package/dist/@comps/Functions/Layout/PageRouter.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="react" />
+export declare const PageRouter: React.FC<amotify.fn.Layout.PageRouter.RouterProps>;

package/dist/@comps/Functions/Layout/PageRouter.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PageRouter = void 0;
+var _global_1 = require("@global");
+var _functions_1 = require("@functions");
+var useEffect = React.useEffect, useRef = React.useRef;
+var useHistory = _global_1.ReactRouterDom.useHistory, useLocation = _global_1.ReactRouterDom.useLocation, BrowserRouter = _global_1.ReactRouterDom.BrowserRouter, Switch = _global_1.ReactRouterDom.Switch, Route = _global_1.ReactRouterDom.Route;
+var userEffect = function (beforeCallback, afterCallback, afterFirstCallback) {
+    var mounted = useRef(false);
+    var location = useLocation();
+    var history = useHistory();
+    _global_1.useStore.set({
+        key: 'history',
+        value: history
+    });
+    amotify.fn.Sheet.closeAll(true);
+    useEffect(function () {
+        if (mounted.current) {
+            $('#TopNavigation')
+                .callback(function (topHeader) {
+                var Body = $(document.body);
+                if (topHeader[0]) {
+                    Body.setStyleProperty('--topNavHeight', topHeader.position().height + 'px');
+                }
+                else {
+                    Body.setStyleProperty('--topNavHeight', '0px');
+                }
+            });
+        }
+        else {
+            mounted.current = true;
+        }
+    }, [location]);
+    if (beforeCallback)
+        beforeCallback(location);
+    useEffect(function () {
+        if (afterFirstCallback)
+            afterFirstCallback(location);
+    }, []);
+    useEffect(function () {
+        setTimeout(function () {
+            window.dispatchEvent(new Event('resize'));
+        }, 200);
+        if (afterCallback)
+            afterCallback(location);
+    }, [location]);
+};
+var Switcher = function (props) {
+    var routes = props.routes, beforeCallBack = props.beforeCallBack, afterCallBack = props.afterCallBack, afterFirstCallBack = props.afterFirstCallBack;
+    userEffect(beforeCallBack, afterCallBack, afterFirstCallBack);
+    var Routes = routes.map(function (page) {
+        var path = page.path, content = page.content;
+        path = '/' + path.replace(/^\//, '');
+        return (React.createElement(Route, { key: path, exact: true, path: path, render: function () { return (React.createElement(React.Fragment, null, content)); } }));
+    });
+    return (React.createElement(Switch, null,
+        Routes,
+        React.createElement(Route, { path: '*', render: function () { return (React.createElement(React.Fragment, null,
+                React.createElement(_functions_1.Layout.PageNotFound, null))); } })));
+};
+var PageRouter = function (props) {
+    var pages = props.pages, beforeCallBack = props.beforeCallBack, afterCallBack = props.afterCallBack, afterFirstCallBack = props.afterFirstCallBack;
+    return (React.createElement(Switcher, { routes: pages, beforeCallBack: beforeCallBack, afterCallBack: afterCallBack, afterFirstCallBack: afterFirstCallBack }));
+};
+exports.PageRouter = PageRouter;

package/dist/@comps/Functions/Layout/PageViewController/parts.d.ts

@@ -0,0 +1 @@
+export declare const PageViewController: FNC<amotify.fn.Layout.PageViewController.Params>;

package/dist/@comps/Functions/Layout/PageViewController/parts.js

@@ -0,0 +1,30 @@
+"use strict";
+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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PageViewController = void 0;
+var _a = amotify.glob.React, useEffect = _a.useEffect, useState = _a.useState;
+var _functions_1 = require("@functions");
+var PageViewController = function (params) {
+    var _a = params.viewIndex, viewIndex = _a === void 0 ? 0 : _a, views = params.views, _b = params.wrapper, wrapper = _b === void 0 ? function (body) { return (React.createElement(_functions_1.Effects.FadeIn, { key: viewIndex, animationTime: 400, children: body })); } : _b;
+    viewIndex = Math.min(Math.max(viewIndex, 0), views.length);
+    var _c = __read(useState(viewIndex), 2), val_index = _c[0], set_index = _c[1];
+    if (val_index != viewIndex)
+        set_index(viewIndex);
+    return (React.createElement(React.Fragment, null, wrapper(views[viewIndex])));
+};
+exports.PageViewController = PageViewController;

package/dist/@comps/Functions/Layout/Plate.d.ts

@@ -0,0 +1 @@
+export declare const Plate: FNC<amotify.fn.Layout.Plate.Params>;

package/dist/@comps/Functions/Layout/Plate.js

@@ -0,0 +1,39 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Plate = void 0;
+var _atoms_1 = require("@atoms");
+var Plate = function (props) {
+    var _a = props.size, size = _a === void 0 ? 'R' : _a, others = __rest(props, ["size"]);
+    var Size = {
+        'XS': 48,
+        'S': 60,
+        'R': 72,
+        'L': 84,
+        'XL': 100,
+        'MAX': 120,
+    }[size];
+    return (React.createElement(_atoms_1.Box, __assign({ margin: [0, 'auto'], width: 1 }, others, { freeCSS: __assign({ maxWidth: 12 * Size }, others.freeCSS) })));
+};
+exports.Plate = Plate;

package/dist/@comps/Functions/Layout/RootViewController/parts.d.ts

@@ -0,0 +1 @@
+export declare const RootViewController: amotify.fn.Layout.RootViewController.Methods;