@steroidsjs/core 2.2.75 → 2.2.78

package/utils/data.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Normalize items for save to state. Support enum class or normal items list.
+ * @param {array|object} items
+ * @returns {*}
+ */
+export declare const normalizeItems: (items: any) => any;
+export declare const checkCondition: (item: any, condition: any) => any;
+export declare const filterItems: (items: Array<any>, condition: any) => any[];
+export declare const shouldUpdate: (objA: any, objB: any, deepPaths?: any) => boolean;

package/utils/data.js

@@ -0,0 +1,159 @@
+"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 };
+};
+exports.__esModule = true;
+exports.shouldUpdate = exports.filterItems = exports.checkCondition = exports.normalizeItems = void 0;
+var uniqBy_1 = __importDefault(require("lodash-es/uniqBy"));
+var isString_1 = __importDefault(require("lodash-es/isString"));
+var isArray_1 = __importDefault(require("lodash-es/isArray"));
+var some_1 = __importDefault(require("lodash-es/some"));
+var has_1 = __importDefault(require("lodash-es/has"));
+var isObject_1 = __importDefault(require("lodash-es/isObject"));
+var isInteger_1 = __importDefault(require("lodash-es/isInteger"));
+var isFunction_1 = __importDefault(require("lodash-es/isFunction"));
+var every_1 = __importDefault(require("lodash-es/every"));
+/**
+ * Normalize items for save to state. Support enum class or normal items list.
+ * @param {array|object} items
+ * @returns {*}
+ */
+var normalizeItems = function (items) {
+    // Array
+    if (isArray_1["default"](items)) {
+        // List of strings/numbers
+        if (some_1["default"](items, function (item) { return isString_1["default"](item) || isInteger_1["default"](item); })) {
+            return items.map(function (item) {
+                if (isString_1["default"](item) || isInteger_1["default"](item)) {
+                    return {
+                        id: item,
+                        label: item
+                    };
+                }
+                return item;
+            });
+        }
+        // Labels as ids
+        if (some_1["default"](items, function (item) { return !has_1["default"](item, 'id'); })) {
+            return uniqBy_1["default"](items.map(function (item) { return (__assign({ id: item.label }, item)); }), 'label');
+        }
+        return items;
+    }
+    // Enum
+    if (isObject_1["default"](items) && isFunction_1["default"](items.getLabels)) {
+        var labels_1 = items.getLabels();
+        return Object.keys(labels_1).map(function (id) { return ({
+            id: id,
+            label: labels_1[id]
+        }); });
+    }
+    return [];
+};
+exports.normalizeItems = normalizeItems;
+var checkCondition = function (item, condition) {
+    if (isObject_1["default"](condition) && !isArray_1["default"](condition)) {
+        return every_1["default"](Object.keys(condition), function (key) {
+            var value = condition[key];
+            var operator = isString_1["default"](value) ? 'like' : '=';
+            return exports.checkCondition(item, [operator, key, value]);
+        });
+    }
+    if (isArray_1["default"](condition) && condition.length > 1) {
+        var operator = condition[0].toLowerCase();
+        // ['not', {role: 'admin'}]
+        if (operator.indexOf('not') === 0) {
+            var newOperator = operator.replace(/^not\s+/, '');
+            return !exports.checkCondition(item, [newOperator].concat(condition.slice(1)));
+        }
+        var key = condition[1];
+        var value = condition[2];
+        switch (operator) {
+            case '=': // ['=', 'age', 18]
+                return item[key] === value;
+            case '>': // ['>', 'age', 18]
+                return item[key] > value;
+            case '>=': // ['>=', 'age', 18]
+            case '=>':
+                return item[key] >= value;
+            case '<': // ['<', 'age', 18]
+                return item[key] < value;
+            case '<=': // ['<=', 'age', 18]
+            case '=<':
+                return item[key] <= value;
+            case 'and': // ['and', {isActive: true}, ['=', 'name', 'Ivan']]
+            case '&&':
+                return every_1["default"](condition.slice(1), function (subCondition) { return exports.checkCondition(item, subCondition); });
+            case 'or': // ['or', {isAdmin: true}, ['=', 'name', 'Ivan']]
+            case '||':
+                return some_1["default"](condition.slice(1), function (subCondition) { return exports.checkCondition(item, subCondition); });
+            case 'like': // ['like', 'name', 'alex']
+                return isString_1["default"](item[key]) && item[key].toLowerCase().indexOf(value.toLowerCase()) !== -1;
+            case 'between': // ['between', 'size', 5, 10]
+                return condition[2] <= value && value <= condition[3];
+            case 'in': // ['in', 'ids', [5, 6, 10]]
+                return isArray_1["default"](item[key]) && item[key].includes(value);
+            default:
+                throw Error('Wrong operator: ' + operator);
+        }
+    }
+    if (isFunction_1["default"](condition)) {
+        return !!condition(item);
+    }
+    return true;
+};
+exports.checkCondition = checkCondition;
+var filterItems = function (items, condition) { return items.filter(function (item) { return exports.checkCondition(item, condition); }); };
+exports.filterItems = filterItems;
+var shouldUpdateSingle = function (a, b) {
+    if (isFunction_1["default"](a) && isFunction_1["default"](b)) {
+        return false;
+    }
+    return a !== b;
+};
+var shouldUpdate = function (objA, objB, deepPaths) {
+    if (deepPaths === void 0) { deepPaths = null; }
+    if (isObject_1["default"](objA) && isObject_1["default"](objB)) {
+        var keysA = Object.keys(objA);
+        var keysB = Object.keys(objB);
+        if (keysA.length !== keysB.length) {
+            return true;
+        }
+        // Convert deep paths to array of arrays
+        if (deepPaths) {
+            deepPaths = deepPaths.map(function (p) { return isString_1["default"](p) ? p.split('.') : p; });
+        }
+        var _loop_1 = function (i) {
+            var key = keysA[i];
+            var deepPath = null;
+            if (deepPaths) {
+                deepPath = deepPaths.find(function (p) { return p[0] === key; }) || null;
+            }
+            var hasChanges = deepPath
+                ? exports.shouldUpdate(objA[key], objB[key], deepPath)
+                : shouldUpdateSingle(objA[key], objB[key]);
+            if (hasChanges) {
+                console.log(0, 'shouldUpdate changed key:', key, objA[key], objB[key]);
+                return { value: true };
+            }
+        };
+        for (var i = 0; i < keysA.length; i += 1) {
+            var state_1 = _loop_1(i);
+            if (typeof state_1 === "object")
+                return state_1.value;
+        }
+        return false;
+    }
+    return shouldUpdateSingle(objA, objB);
+};
+exports.shouldUpdate = shouldUpdate;

package/utils/form.d.ts

@@ -0,0 +1,34 @@
+/// <reference types="react" />
+export declare const setInWithPath: (state: any, value: any, path: string[], pathIndex?: number) => any;
+export declare const normalizeLayout: (layout: any) => any;
+export declare const mergeLayoutProp: (layout1: any, layout2: any) => any;
+export declare const cleanEmptyObject: (object: any) => any;
+export declare const providers: {
+    redux: {
+        useForm: (formId: any, initialValues: any) => any;
+        useField: (formId: any, name: any, isList: any) => {
+            setValue: (value: any) => any;
+            errors: any;
+            value: any;
+        };
+        useDispatch: () => any;
+        select: (formId: any, selector: any) => any;
+    };
+    reducer: {
+        useForm: (formId: any, initialValues: any) => any;
+        useField: (formId: any, name: any, isList: any) => {
+            errors: any;
+            value: any;
+            setValue: (newValue: any) => void;
+        };
+        useDispatch: () => import("react").Dispatch<any>;
+        select: (formId: any, selector: any) => any;
+    };
+    state: {
+        useField: (initialValue: any) => {
+            errors: any;
+            value: any;
+            setValue: import("react").Dispatch<any>;
+        };
+    };
+};

package/utils/form.js

@@ -0,0 +1,175 @@
+"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 };
+};
+exports.__esModule = true;
+exports.providers = exports.cleanEmptyObject = exports.mergeLayoutProp = exports.normalizeLayout = exports.setInWithPath = void 0;
+var isPlainObject_1 = __importDefault(require("lodash-es/isPlainObject"));
+var isArray_1 = __importDefault(require("lodash-es/isArray"));
+var isEqual_1 = __importDefault(require("lodash-es/isEqual"));
+var get_1 = __importDefault(require("lodash-es/get"));
+var react_1 = require("react");
+var react_use_1 = require("react-use");
+var useDispatch_1 = __importDefault(require("../hooks/useDispatch"));
+var hooks_1 = require("../hooks");
+var Form_1 = require("../ui/form/Form/Form");
+var form_1 = require("../actions/form");
+var form_2 = require("../reducers/form");
+var setInWithPath = function (state, value, path, pathIndex) {
+    var _a, _b;
+    if (pathIndex === void 0) { pathIndex = 0; }
+    if (pathIndex >= path.length) {
+        return value;
+    }
+    var first = path[pathIndex];
+    var firstState = state && (Array.isArray(state) ? state[Number(first)] : state[first]);
+    var next = exports.setInWithPath(firstState, value, path, pathIndex + 1);
+    if (!state) {
+        if (Number.isNaN(first)) {
+            return _a = {}, _a[first] = next, _a;
+        }
+        var initialized = [];
+        initialized[parseInt(first, 10)] = next;
+        return initialized;
+    }
+    if (Array.isArray(state)) {
+        var copy = [].concat(state);
+        copy[parseInt(first, 10)] = next;
+        return copy;
+    }
+    return __assign(__assign({}, state), (_b = {}, _b[first] = next, _b));
+};
+exports.setInWithPath = setInWithPath;
+var normalizeLayout = function (layout) { return (typeof layout === 'object' ? layout : { layout: layout }); };
+exports.normalizeLayout = normalizeLayout;
+var mergeLayoutProp = function (layout1, layout2) {
+    if (layout2 === false) {
+        return null;
+    }
+    layout1 = layout1 ? exports.normalizeLayout(layout1) : null;
+    layout2 = layout2 ? exports.normalizeLayout(layout2) : null;
+    return layout1 || layout2 ? __assign(__assign({}, layout1), layout2) : null;
+};
+exports.mergeLayoutProp = mergeLayoutProp;
+var cleanEmptyObject = function (object) {
+    // if all properties are null substitute the object with null
+    if (!Object.values(object).some(function (x) { return x; })) {
+        return null;
+    }
+    Object.keys(object).forEach(function (key) {
+        if (isPlainObject_1["default"](object[key])) {
+            object[key] = exports.cleanEmptyObject(object[key]);
+        }
+        if (isArray_1["default"](object[key])) {
+            var array_1 = object[key];
+            array_1.forEach(function (value, index) {
+                if (isPlainObject_1["default"](value)) {
+                    array_1[index] = exports.cleanEmptyObject(value);
+                }
+            });
+            if (!object[key].some(function (x) { return Boolean(x); })) {
+                object[key] = [];
+            }
+        }
+    });
+    return object;
+};
+exports.cleanEmptyObject = cleanEmptyObject;
+// Form state providers
+exports.providers = {
+    // Redux
+    redux: {
+        useForm: function (formId, initialValues) {
+            var dispatch = useDispatch_1["default"](); // eslint-disable-line react-hooks/rules-of-hooks
+            react_use_1.useEffectOnce(function () {
+                dispatch(form_1.formInitialize(formId, initialValues));
+            });
+            return __assign(__assign({}, hooks_1.useSelector(function (state) { return get_1["default"](state, ['form', formId]); })), { setErrors: react_1.useCallback(function (errors) { return dispatch(form_1.formSetErrors(formId, errors)); }, [dispatch, formId]), reducer: null, setState: null, dispatch: dispatch });
+        },
+        useField: function (formId, name, isList) {
+            var dispatch = useDispatch_1["default"](); // eslint-disable-line react-hooks/rules-of-hooks
+            return __assign(__assign({}, hooks_1.useSelector(function (state) {
+                var errors = get_1["default"](state, ['form', formId, 'errors'].concat(name.split('.')));
+                var value = get_1["default"](state, ['form', formId, 'values'].concat(name.split('.')));
+                return {
+                    errors: errors,
+                    value: isList ? (value === null || value === void 0 ? void 0 : value.length) || 0 : value
+                };
+            })), { setValue: react_1.useCallback(function (value) { return dispatch(form_1.formChange(formId, name, value)); }, [dispatch, formId, name]) });
+        },
+        useDispatch: function () { return useDispatch_1["default"](); },
+        // eslint-disable-next-line react-hooks/rules-of-hooks
+        select: function (formId, selector) { return hooks_1.useSelector(function (state) { return selector(get_1["default"](state, ['form', formId])); }); }
+    },
+    // React reducer
+    reducer: {
+        useForm: function (formId, initialValues) {
+            var initialState = form_2.reducerItem({}, form_1.formInitialize(formId, initialValues));
+            var _a = react_1.useReducer(form_2.reducerItem, initialState), state = _a[0], dispatch = _a[1];
+            var subscribersRef = react_1.useRef([]);
+            react_1.useEffect(function () {
+                subscribersRef.current.forEach(function (callback) { return callback(state); });
+            }, [state]);
+            var reducer = react_1.useMemo(function () { return ({
+                dispatch: dispatch,
+                select: function (selector) {
+                    // eslint-disable-next-line react-hooks/rules-of-hooks
+                    var forceUpdate = react_use_1.useUpdate();
+                    // eslint-disable-next-line react-hooks/rules-of-hooks
+                    var valueRef = react_1.useRef(selector.call(null, state));
+                    // eslint-disable-next-line react-hooks/rules-of-hooks
+                    var callback = react_1.useCallback(function (newSstate) {
+                        var newValue2 = selector.call(null, newSstate);
+                        if (!isEqual_1["default"](valueRef.current, newValue2)) {
+                            valueRef.current = newValue2;
+                            forceUpdate();
+                        }
+                    }, []); // eslint-disable-line react-hooks/exhaustive-deps
+                    // eslint-disable-next-line react-hooks/rules-of-hooks
+                    react_use_1.useLifecycles(function () { return subscribersRef.current.push(callback); }, function () {
+                        var index = subscribersRef.current.indexOf(callback);
+                        if (index !== -1) {
+                            subscribersRef.current.splice(index, 1);
+                        }
+                    });
+                    return valueRef.current;
+                }
+            }); }, []); // eslint-disable-line react-hooks/exhaustive-deps
+            return __assign(__assign({}, state), { setErrors: react_1.useCallback(function (errors) { return dispatch(form_1.formSetErrors(formId, errors)); }, [dispatch, formId]), reducer: reducer, setState: null, dispatch: dispatch });
+        },
+        useField: function (formId, name, isList) {
+            var reducer = react_1.useContext(Form_1.FormContext).reducer; // eslint-disable-line react-hooks/rules-of-hooks
+            var value = reducer.select(function (state) { return get_1["default"](state, 'values.' + name); });
+            return {
+                errors: reducer.select(function (state) { return get_1["default"](state, 'errors.' + name); }),
+                value: isList ? (value === null || value === void 0 ? void 0 : value.length) || 0 : value,
+                setValue: react_1.useCallback(function (newValue) { return reducer.dispatch(form_1.formChange(formId, name, newValue)); }, [reducer, formId, name])
+            };
+        },
+        useDispatch: function () { return react_1.useContext(Form_1.FormContext).reducer.dispatch; },
+        // eslint-disable-next-line react-hooks/rules-of-hooks
+        select: function (formId, selector) { return react_1.useContext(Form_1.FormContext).reducer.select(selector); }
+    },
+    // Local component state
+    state: {
+        useField: function (initialValue) {
+            var _a = react_1.useState(initialValue), value = _a[0], setValue = _a[1]; // eslint-disable-line react-hooks/rules-of-hooks
+            return {
+                errors: null,
+                value: value,
+                setValue: setValue
+            };
+        }
+    }
+};

package/utils/text.d.ts

@@ -0,0 +1,16 @@
+interface ISmartSearchSourceItem {
+    id: string | number;
+    label: string | number;
+}
+interface ISmartSearchOutputItem extends ISmartSearchSourceItem {
+    labelHighlighted?: [string, boolean][];
+}
+export declare type TSmartSearchOutput = ISmartSearchOutputItem[];
+/**
+ * Регистронезависимый поиск.
+ *
+ * @param query
+ * @param sourceItems
+ */
+export declare const smartSearch: (query: string, sourceItems: ISmartSearchSourceItem[]) => TSmartSearchOutput;
+export {};

package/utils/text.js

@@ -0,0 +1,96 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+exports.__esModule = true;
+exports.smartSearch = void 0;
+var orderBy_1 = __importDefault(require("lodash-es/orderBy"));
+var stringToWords = function (str) {
+    var words = [];
+    String(str).split(' ').forEach(function (strItem) {
+        words = words.concat(strItem.match(/^[^\p{Lu}]+/u));
+        words = words.concat(strItem.match(/[\p{Lu}][^\p{Lu}]*/gu));
+        words.push(' ');
+    });
+    words.pop();
+    return words.filter(Boolean);
+};
+/**
+ * Регистронезависимый поиск.
+ *
+ * @param query
+ * @param sourceItems
+ */
+// eslint-disable-next-line import/prefer-default-export
+var smartSearch = function (query, sourceItems) {
+    if (!query) {
+        return sourceItems;
+    }
+    var queryCharacters = query.split('');
+    // Match
+    var items = sourceItems.filter(function (item) {
+        var id = item.id;
+        var words = stringToWords(item.label || '');
+        if (words.length === 0 || !id) {
+            return false;
+        }
+        var word = null;
+        var highlighted = [['', false]];
+        var index = 0;
+        var wordIndex = 0;
+        var wordChar = null;
+        var wordCharIndex = 0;
+        var prevIsMatch = false;
+        // eslint-disable-next-line no-constant-condition
+        while (true) {
+            var char = queryCharacters[index];
+            if (!char) {
+                highlighted.push([
+                    word.substr(wordCharIndex) + words.slice(wordIndex + 1).join(''),
+                    false,
+                ]);
+                break;
+            }
+            word = words[wordIndex];
+            wordChar = (word && word.split('')[wordCharIndex]) || '';
+            if (!word) {
+                highlighted = [];
+                break;
+            }
+            var isMatch = wordChar.toLowerCase() === char.toLowerCase();
+            if (isMatch) {
+                index += 1;
+                wordCharIndex += 1;
+                highlighted[highlighted.length - 1][0] += wordChar;
+                highlighted[highlighted.length - 1][1] = true;
+                prevIsMatch = true;
+            }
+            else {
+                if (!prevIsMatch) {
+                    index = 0;
+                }
+                highlighted.push([word.substr(wordCharIndex), false]);
+                highlighted.push(['', false]);
+                wordIndex += 1;
+                wordCharIndex = 0;
+                prevIsMatch = false;
+            }
+        }
+        highlighted = highlighted.filter(function (highlightedItem) { return !!highlightedItem[0]; });
+        if (highlighted.findIndex(function (highlightedItem) { return highlightedItem[1]; }) !== -1) {
+            // @ts-ignore
+            item.labelHighlighted = highlighted;
+            return true;
+        }
+        return false;
+    });
+    items = orderBy_1["default"](items, function (item) {
+        // Fined first word is priority
+        if (item.labelHighlighted) {
+            return item.labelHighlighted.findIndex(function (i) { return i[1]; });
+        }
+        return Infinity;
+    }, 'asc');
+    return items;
+};
+exports.smartSearch = smartSearch;

package/.babelrc.json

@@ -1,34 +0,0 @@
-{
-  "plugins": [
-    [
-      "@babel/plugin-proposal-decorators",
-      {
-        "legacy": true
-      }
-    ],
-    "@babel/plugin-proposal-class-properties",
-    "@babel/plugin-syntax-dynamic-import",
-    "@babel/plugin-transform-modules-commonjs",
-    "@babel/plugin-transform-runtime"
-  ],
-  "presets": [
-    [
-      "@babel/preset-env",
-      {
-        "targets": {
-          "browsers": "last 2 versions, Android >= 4, safari >= 7, ios_saf >= 8, chrome >= 52"
-        },
-        "corejs": "^3.0.1",
-        "useBuiltIns": "entry"
-      }
-    ],
-    "@babel/preset-react",
-    [
-      "@babel/preset-typescript",
-      {
-        "isTSX": true,
-        "allExtensions": true
-      }
-    ]
-  ]
-}

package/.eslintrc

@@ -1,6 +0,0 @@
-{
-  "extends": "@steroidsjs/eslint-config",
-  "rules": {
-    "linebreak-style": 0
-  }
-}

package/.github/workflows/publish.yml

@@ -1,22 +0,0 @@
-name: NPM Publish
-on:
-  push:
-    branches:
-      - 'master'
-jobs:
-  publish:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v1
-      - uses: actions/setup-node@v1
-        with:
-          node-version: 12
-      - run: yarn
-      - run: yarn upgrade @steroidsjs/core
-      - run: yarn tsc
-      - run: cp ./{package.json,LICENSE,README.md} dist/
-      - run: cp src/index.d.ts dist/
-      - uses: JS-DevTools/npm-publish@v1
-        with:
-          package: ./dist/package.json
-          token: ${{ secrets.NPM_TOKEN }}

package/.github/workflows/test.yml

@@ -1,15 +0,0 @@
-name: Test
-on: push
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - uses: actions/checkout@v2
-        with:
-          repository: steroids/react-bootstrap
-          ref: master
-          path: react-bootstrap
-      - run: yarn
-      - run: cd react-bootstrap && yarn
-      - run: yarn test

package/.idea/inspectionProfiles/Project_Default.xml

@@ -1,6 +0,0 @@
-<component name="InspectionProjectProfileManager">
-  <profile version="1.0">
-    <option name="myName" value="Project Default" />
-    <inspection_tool class="Eslint" enabled="true" level="WARNING" enabled_by_default="true" />
-  </profile>
-</component>

package/.idea/modules.xml

@@ -1,8 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="ProjectModuleManager">
-    <modules>
-      <module fileurl="file://$PROJECT_DIR$/.idea/react.iml" filepath="$PROJECT_DIR$/.idea/react.iml" />
-    </modules>
-  </component>
-</project>

package/.idea/react.iml

@@ -1,8 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<module type="WEB_MODULE" version="4">
-  <component name="NewModuleRootManager">
-    <content url="file://$MODULE_DIR$" />
-    <orderEntry type="inheritedJdk" />
-    <orderEntry type="sourceFolder" forTests="false" />
-  </component>
-</module>

package/.idea/vcs.xml

@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="VcsDirectoryMappings">
-    <mapping directory="$PROJECT_DIR$" vcs="Git" />
-  </component>
-</project>