sculp-js 0.0.1

package/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020-present, [chandq](https://github.com/chandq)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,3 @@
+# sculp-js
+
+> js 工具库

package/lib/cjs/array.js

@@ -0,0 +1,217 @@
+/*!
+ * sculp-js v0.0.1
+ * (c) 2023-2023 chandq
+ * Released under the MIT License.
+ */
+
+'use strict';
+
+var object = require('./object.js');
+var type = require('./type.js');
+
+/**
+ * 判断一个对象是否为类数组
+ * @param any
+ * @returns {boolean}
+ */
+const arrayLike = (any) => {
+    if (type.isArray(any))
+        return true;
+    if (type.isString(any))
+        return true;
+    if (!type.isObject(any))
+        return false;
+    return object.objectHas(any, 'length');
+};
+/**
+ * 遍历数组，返回 false 中断遍历
+ * @param {ArrayLike<V>} array
+ * @param {(val: V, idx: number) => any} iterator
+ * @param reverse {boolean} 是否倒序
+ */
+const arrayEach = (array, iterator, reverse = false) => {
+    if (reverse) {
+        for (let idx = array.length - 1; idx >= 0; idx--) {
+            const val = array[idx];
+            if (iterator(val, idx) === false)
+                break;
+        }
+    }
+    else {
+        for (let idx = 0; idx < array.length; idx++) {
+            const val = array[idx];
+            if (iterator(val, idx) === false)
+                break;
+        }
+    }
+};
+/**
+ * 异步遍历数组，返回 false 中断遍历
+ * @param {ArrayLike<V>} array
+ * @param {(val: V, idx: number) => Promise<any>} iterator
+ * @param {boolean} reverse
+ */
+async function arrayEachAsync(array, iterator, reverse = false) {
+    if (reverse) {
+        for (let idx = array.length - 1; idx >= 0; idx--) {
+            const val = array[idx];
+            if ((await iterator(val, idx)) === false)
+                break;
+        }
+    }
+    else {
+        for (let idx = 0; idx < array.length; idx++) {
+            const val = array[idx];
+            if ((await iterator(val, idx)) === false)
+                break;
+        }
+    }
+}
+/**
+ * 插入到目标位置之前
+ * @param {AnyArray} array
+ * @param {number} start
+ * @param {number} to
+ */
+const arrayInsertBefore = (array, start, to) => {
+    if (start === to || start + 1 === to)
+        return;
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    const [source] = array.splice(start, 1);
+    const insertIndex = to < start ? to : to - 1;
+    array.splice(insertIndex, 0, source);
+};
+/**
+ * 数组删除指定项目
+ * @param {V[]} array
+ * @param {(val: V, idx: number) => boolean} expect
+ * @returns {V[]}
+ */
+function arrayRemove(array, expect) {
+    const indexes = [];
+    // 这里重命名一下：是为了杜绝 jest 里的 expect 与之产生检查错误
+    // eslint 的 jest 语法检查是遇到 expect 函数就以为是单元测试
+    const _expect = expect;
+    arrayEach(array, (val, idx) => {
+        if (_expect(val, idx))
+            indexes.push(idx);
+    });
+    indexes.forEach((val, idx) => array.splice(val - idx, 1));
+    return array;
+}
+/**
+ * 自定义深度优先遍历函数(支持continue和break操作)
+ * @param {array} deepList
+ * @param {function} iterator
+ * @param {array} children
+ * @param {boolean} isReverse 是否反向遍历
+ */
+const deepTraversal = (deepList, iterator, children = 'children', isReverse = false) => {
+    let level = 0;
+    const walk = (arr, parent) => {
+        if (isReverse) {
+            for (let i = arr.length - 1; i >= 0; i--) {
+                const re = iterator(arr[i], i, deepList, parent, level);
+                if (re === 'break') {
+                    break;
+                }
+                else if (re === 'continue') {
+                    continue;
+                }
+                // @ts-ignore
+                if (Array.isArray(arr[i][children])) {
+                    ++level;
+                    // @ts-ignore
+                    walk(arr[i][children], arr[i]);
+                }
+            }
+        }
+        else {
+            for (let i = 0; i < arr.length; i++) {
+                const re = iterator(arr[i], i, deepList, parent, level);
+                if (re === 'break') {
+                    break;
+                }
+                else if (re === 'continue') {
+                    continue;
+                }
+                // @ts-ignore
+                if (Array.isArray(arr[i][children])) {
+                    ++level;
+                    // @ts-ignore
+                    walk(arr[i][children], arr[i]);
+                }
+            }
+        }
+    };
+    walk(deepList, null);
+};
+/**
+ * 在树中找到 id 为某个值的节点，并返回上游的所有父级节点
+ * @param {ArrayLike<T>} tree
+ * @param {IdLike} nodeId
+ * @param {ITreeConf} config
+ * @return {[IdLike[], ITreeItem<V>[]]}
+ */
+function getTreeIds(tree, nodeId, config) {
+    const { children = 'children', id = 'id' } = config || {};
+    const toFlatArray = (tree, parentId, parent) => {
+        return tree.reduce((t, _) => {
+            const child = _[children];
+            return [
+                ...t,
+                parentId ? { ..._, parentId, parent } : _,
+                ...(child && child.length ? toFlatArray(child, _[id], _) : [])
+            ];
+        }, []);
+    };
+    const getIds = (flatArray) => {
+        let child = flatArray.find(_ => _[id] === nodeId);
+        const { parent, parentId, ...other } = child;
+        let ids = [nodeId], nodes = [other];
+        while (child && child.parentId) {
+            ids = [child.parentId, ...ids];
+            nodes = [child.parent, ...nodes];
+            child = flatArray.find(_ => _[id] === child.parentId);
+        }
+        return [ids, nodes];
+    };
+    return getIds(toFlatArray(tree));
+}
+/**
+ * 异步ForEach函数
+ * @param {array} array
+ * @param {asyncFuntion} callback
+ * // asyncForEach 使用范例如下
+// const start = async () => {
+//   await asyncForEach(result, async (item) => {
+//     await request(item);
+//     count++;
+//   });
+
+//   console.log('发送次数', count);
+// }
+
+// for await...of 使用范例如下
+// const loadImages =  async (images) => {
+//   for await (const item of images) {
+//      await request(item);
+//      count++;
+//    }
+// }
+ * @return {*}
+ */
+async function asyncForEach(array, callback) {
+    for (let index = 0, len = array.length; index < len; index++) {
+        await callback(array[index], index, array);
+    }
+}
+
+exports.arrayEach = arrayEach;
+exports.arrayEachAsync = arrayEachAsync;
+exports.arrayInsertBefore = arrayInsertBefore;
+exports.arrayLike = arrayLike;
+exports.arrayRemove = arrayRemove;
+exports.asyncForEach = asyncForEach;
+exports.deepTraversal = deepTraversal;
+exports.getTreeIds = getTreeIds;

package/lib/cjs/async.js

@@ -0,0 +1,63 @@
+/*!
+ * sculp-js v0.0.1
+ * (c) 2023-2023 chandq
+ * Released under the MIT License.
+ */
+
+'use strict';
+
+/**
+ * 等待一段时间
+ * @param {number} timeout 等待时间，单位毫秒
+ * @returns {Promise<void>}
+ */
+async function wait(timeout = 1) {
+    return new Promise(resolve => setTimeout(resolve, timeout));
+}
+/**
+ * 异步遍历
+ * @ref https://github.com/Kevnz/async-tools/blob/master/src/mapper.js
+ * @ref https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Array/@@iterator
+ * @param {Array<T>} list
+ * @param {(val: T, idx: number, list: ArrayLike<T>) => Promise<R>} mapper
+ * @param {number} concurrency 并发数量，默认无限
+ * @returns {Promise<R[]>}
+ */
+async function asyncMap(list, mapper, concurrency = Infinity) {
+    return new Promise((resolve, reject) => {
+        const iterator = list[Symbol.iterator]();
+        const limit = Math.min(list.length, concurrency);
+        const resolves = [];
+        let resolvedLength = 0;
+        let rejected;
+        let index = 0;
+        const next = () => {
+            if (rejected)
+                return reject(rejected);
+            const it = iterator.next();
+            if (it.done) {
+                if (resolvedLength === list.length)
+                    resolve(resolves);
+                return;
+            }
+            const current = index++;
+            mapper(it.value, current, list)
+                .then(value => {
+                resolvedLength++;
+                resolves[current] = value;
+                next();
+            })
+                .catch(err => {
+                rejected = err;
+                next();
+            });
+        };
+        // 开始
+        for (let i = 0; i < limit; i++) {
+            next();
+        }
+    });
+}
+
+exports.asyncMap = asyncMap;
+exports.wait = wait;

package/lib/cjs/clipboard.js

@@ -0,0 +1,36 @@
+/*!
+ * sculp-js v0.0.1
+ * (c) 2023-2023 chandq
+ * Released under the MIT License.
+ */
+
+'use strict';
+
+var dom = require('./dom.js');
+
+const textEl = document.createElement('textarea');
+dom.setStyle(textEl, {
+    position: 'absolute',
+    top: '-9999px',
+    left: '-9999px',
+    opacity: 0
+});
+document.body.appendChild(textEl);
+/**
+ * 复制文本
+ * @param {string} text
+ */
+const copyText = (text) => {
+    textEl.value = text;
+    textEl.focus({ preventScroll: true });
+    textEl.select();
+    try {
+        document.execCommand('copy');
+        textEl.blur();
+    }
+    catch (err) {
+        // ignore
+    }
+};
+
+exports.copyText = copyText;

package/lib/cjs/cookie.js

@@ -0,0 +1,63 @@
+/*!
+ * sculp-js v0.0.1
+ * (c) 2023-2023 chandq
+ * Released under the MIT License.
+ */
+
+'use strict';
+
+var type = require('./type.js');
+
+/**
+ * 获取cookie
+ * @param {string} name
+ * @returns {string}
+ */
+const cookieGet = (name) => {
+    const { cookie } = document;
+    if (!cookie)
+        return '';
+    const result = cookie.split(';');
+    for (let i = 0; i < result.length; i++) {
+        const item = result[i];
+        const [key, val = ''] = item.split('=');
+        if (key === name)
+            return decodeURIComponent(val);
+    }
+    return '';
+};
+/**
+ * 设置 cookie
+ * @param {string} name
+ * @param {string} value
+ * @param {number | Date} [maxAge]
+ */
+const cookieSet = (name, value, maxAge) => {
+    const metas = [];
+    const EXPIRES = 'expires';
+    metas.push([name, encodeURIComponent(value)]);
+    if (type.isNumber(maxAge)) {
+        const d = new Date();
+        d.setTime(d.getTime() + maxAge);
+        metas.push([EXPIRES, d.toUTCString()]);
+    }
+    else if (type.isDate(maxAge)) {
+        metas.push([EXPIRES, maxAge.toUTCString()]);
+    }
+    metas.push(['path', '/']);
+    document.cookie = metas
+        .map(item => {
+        const [key, val] = item;
+        return `${key}=${val}`;
+    })
+        .join(';');
+};
+/**
+ * 删除单个 cookie
+ * @param name cookie 名称
+ */
+const cookieDel = (name) => cookieSet(name, '', -1);
+
+exports.cookieDel = cookieDel;
+exports.cookieGet = cookieGet;
+exports.cookieSet = cookieSet;

package/lib/cjs/date.js

@@ -0,0 +1,114 @@
+/*!
+ * sculp-js v0.0.1
+ * (c) 2023-2023 chandq
+ * Released under the MIT License.
+ */
+
+'use strict';
+
+/**
+ * 格式化为日期对象(带自定义格式化模板)
+ * @param {DateValue} value 可以是数值、字符串或 Date 对象
+ * @param {string} [format] 模板，默认是 YYYY-MM-DD HH:mm:ss，模板字符：
+ * - YYYY：年
+ * - yyyy: 年
+ * - MM：月
+ * - DD：日
+ * - dd: 日
+ * - HH：时（24 小时制）
+ * - hh：时（12 小时制）
+ * - mm：分
+ * - ss：秒
+ * - SSS：毫秒
+ * - ww: 周
+ * @returns {string}
+ */
+const formatDate = (date = new Date(), format = 'YYYY-MM-DD HH:mm:ss') => {
+    let fmt = format;
+    let ret;
+    const opt = {
+        'Y+': `${date.getFullYear()}`,
+        'y+': `${date.getFullYear()}`,
+        'M+': `${date.getMonth() + 1}`,
+        'D+': `${date.getDate()}`,
+        'd+': `${date.getDate()}`,
+        'H+': `${date.getHours()}`,
+        'm+': `${date.getMinutes()}`,
+        's+': `${date.getSeconds()}`,
+        'S+': `${date.getMilliseconds()}`,
+        'w+': ['周日', '周一', '周二', '周三', '周四', '周五', '周六'][date.getDay()] // 周
+        // 有其他格式化字符需求可以继续添加，必须转化成字符串
+    };
+    for (const k in opt) {
+        ret = new RegExp('(' + k + ')').exec(fmt);
+        if (ret) {
+            fmt = fmt.replace(ret[1], ret[1].length === 1 ? opt[k] : opt[k].padStart(ret[1].length, '0'));
+        }
+    }
+    return fmt;
+};
+/**
+ * 计算向前或向后N天的具体日期
+ * @param {string} strDate 参考日期
+ * @param {number} n 正数：向后推算；负数：向前推算
+ * @param {string} sep 日期格式的分隔符
+ * @return {*} 目标日期
+ */
+function calculateDate(strDate, n, sep = '-') {
+    //strDate 为字符串日期 如:'2019-01-01' n为你要传入的参数，当前为0，前一天为-1，后一天为1
+    let dateArr = strDate.split(sep); //这边给定一个特定时间
+    let newDate = new Date(+dateArr[0], +dateArr[1] - 1, +dateArr[2]);
+    let befminuts = newDate.getTime() + 1000 * 60 * 60 * 24 * parseInt(String(n)); //计算前几天用减，计算后几天用加，最后一个就是多少天的数量
+    let beforeDat = new Date();
+    beforeDat.setTime(befminuts);
+    let befMonth = beforeDat.getMonth() + 1;
+    let mon = befMonth >= 10 ? befMonth : '0' + befMonth;
+    let befDate = beforeDat.getDate();
+    let da = befDate >= 10 ? befDate : '0' + befDate;
+    let finalNewDate = beforeDat.getFullYear() + '-' + mon + '-' + da;
+    return finalNewDate;
+}
+/**
+ * 计算向前或向后N天的具体时间日期
+ * @param {number} n 正数：向后推算；负数：向前推算
+ * @param {string} dateSep 日期分隔符
+ * @param {string} timeSep 时间分隔符
+ * @return {*}
+ */
+function calculateDateTime(n, dateSep = '-', timeSep = ':') {
+    let date = new Date();
+    let separator1 = '-';
+    let separator2 = ':';
+    let year = date.getFullYear();
+    let month = date.getMonth() + 1;
+    let strDate = date.getDate() + n;
+    if (strDate > new Date(year, month, 0).getDate()) {
+        month += 1;
+        strDate -= new Date(year, month, 0).getDate();
+        if (month > 12) {
+            year += 1;
+            month = 1;
+        }
+    }
+    if (month >= 1 && month <= 9) {
+        month = '0' + month;
+    }
+    if (strDate >= 0 && strDate <= 9) {
+        strDate = '0' + strDate;
+    }
+    return (year +
+        separator1 +
+        month +
+        separator1 +
+        strDate +
+        ' ' +
+        date.getHours() +
+        separator2 +
+        date.getMinutes() +
+        separator2 +
+        date.getSeconds());
+}
+
+exports.calculateDate = calculateDate;
+exports.calculateDateTime = calculateDateTime;
+exports.formatDate = formatDate;

package/lib/cjs/dom.js

@@ -0,0 +1,152 @@
+/*!
+ * sculp-js v0.0.1
+ * (c) 2023-2023 chandq
+ * Released under the MIT License.
+ */
+
+'use strict';
+
+var array = require('./array.js');
+var easing = require('./easing.js');
+var object = require('./object.js');
+var string = require('./string.js');
+var type = require('./type.js');
+
+/**
+ * 判断元素是否包含某个样式名
+ * @param {HTMLElement} el
+ * @param {string} className
+ * @returns {boolean}
+ */
+const hasClass = (el, className) => {
+    if (className.indexOf(' ') !== -1)
+        throw new Error('className should not contain space.');
+    return el.classList.contains(className);
+};
+const eachClassName = (classNames, func) => {
+    const classNameList = classNames.split(/\s+/g);
+    classNameList.forEach(func);
+};
+/**
+ * 给元素增加样式名
+ * @param {HTMLElement} el
+ * @param {string} classNames
+ */
+const addClass = (el, classNames) => {
+    eachClassName(classNames, className => el.classList.add(className));
+};
+/**
+ * 给元素移除样式名
+ * @param {HTMLElement} el
+ * @param {string} classNames
+ */
+const removeClass = (el, classNames) => {
+    eachClassName(classNames, className => el.classList.remove(className));
+};
+/**
+ * 设置元素样式
+ * @param {HTMLElement} el
+ * @param {string | Style} key
+ * @param {string} val
+ */
+const setStyle = (el, key, val) => {
+    if (type.isObject(key)) {
+        object.objectEach(key, (val1, key1) => {
+            setStyle(el, key1, val1);
+        });
+    }
+    else {
+        el.style.setProperty(string.stringKebabCase(key), val);
+    }
+};
+/**
+ * 获取元素样式
+ * @param {HTMLElement} el
+ * @param {string} key
+ * @returns {string}
+ */
+const getStyle = (el, key) => getComputedStyle(el).getPropertyValue(key);
+async function smoothScroll(options) {
+    return new Promise(resolve => {
+        const defaults = {
+            el: document,
+            to: 0,
+            duration: 567,
+            easing: 'ease'
+        };
+        const { el, to, duration, easing: easing$1 } = object.objectAssign(defaults, options);
+        const htmlEl = document.documentElement;
+        const bodyEl = document.body;
+        const globalMode = el === window || el === document || el === htmlEl || el === bodyEl;
+        const els = globalMode ? [htmlEl, bodyEl] : [el];
+        const query = () => {
+            let value = 0;
+            array.arrayEach(els, el => {
+                if ('scrollTop' in el) {
+                    value = el.scrollTop;
+                    return false;
+                }
+            });
+            return value;
+        };
+        const update = (val) => {
+            els.forEach(el => {
+                if ('scrollTop' in el) {
+                    el.scrollTop = val;
+                }
+            });
+        };
+        let startTime;
+        const startValue = query();
+        const length = to - startValue;
+        const easingFn = easing.easingFunctional(easing$1);
+        const render = () => {
+            const now = performance.now();
+            const passingTime = startTime ? now - startTime : 0;
+            const t = passingTime / duration;
+            const p = easingFn(t);
+            if (!startTime)
+                startTime = now;
+            update(startValue + length * p);
+            if (t >= 1)
+                resolve();
+            else
+                requestAnimationFrame(render);
+        };
+        render();
+    });
+}
+const domReadyCallbacks = [];
+const eventType = 'DOMContentLoaded';
+const listener = () => {
+    domReadyCallbacks.forEach(callback => callback());
+    domReadyCallbacks.length = 0;
+    document.removeEventListener(eventType, listener);
+};
+document.addEventListener(eventType, listener);
+let readied = false;
+function isDomReady() {
+    if (readied)
+        return true;
+    readied = ['complete', 'loaded', 'interactive'].indexOf(document.readyState) !== -1;
+    return readied;
+}
+function onDomReady(callback) {
+    // document readied
+    if (isDomReady()) {
+        setTimeout(callback, 0);
+    }
+    // listen document to ready
+    else {
+        domReadyCallbacks.push(callback);
+    }
+}
+
+exports.addClass = addClass;
+exports.getStyle = getStyle;
+exports.hasClass = hasClass;
+exports.isDomReady = isDomReady;
+exports.onDomReady = onDomReady;
+exports.removeClass = removeClass;
+exports.setStyle = setStyle;
+exports.smoothScroll = smoothScroll;