sculp-js 0.0.1

package/lib/es/dom.js

@@ -0,0 +1,143 @@
+/*!
+ * sculp-js v0.0.1
+ * (c) 2023-2023 chandq
+ * Released under the MIT License.
+ */
+
+import { arrayEach } from './array.js';
+import { easingFunctional } from './easing.js';
+import { objectEach, objectAssign } from './object.js';
+import { stringKebabCase } from './string.js';
+import { isObject } from './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 (isObject(key)) {
+        objectEach(key, (val1, key1) => {
+            setStyle(el, key1, val1);
+        });
+    }
+    else {
+        el.style.setProperty(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 } = 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;
+            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 = easingFunctional(easing);
+        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);
+    }
+}
+
+export { addClass, getStyle, hasClass, isDomReady, onDomReady, removeClass, setStyle, smoothScroll };

package/lib/es/download.js

@@ -0,0 +1,77 @@
+/*!
+ * sculp-js v0.0.1
+ * (c) 2023-2023 chandq
+ * Released under the MIT License.
+ */
+
+import { urlSetParams } from './url.js';
+
+/**
+ * 通过打开新窗口的方式下载
+ * @param {string} url
+ * @param {LooseParams} params
+ */
+const downloadURL = (url, params) => {
+    window.open(params ? urlSetParams(url, params) : url);
+};
+/**
+ * 通过 A 链接的方式下载
+ * @param {string} href
+ * @param {string} filename
+ */
+const downloadHref = (href, filename) => {
+    const eleLink = document.createElement('a');
+    eleLink.download = filename;
+    eleLink.style.display = 'none';
+    eleLink.href = href;
+    document.body.appendChild(eleLink);
+    eleLink.click();
+    setTimeout(() => document.body.removeChild(eleLink));
+};
+/**
+ * 将大文件对象通过 A 链接的方式下载
+ * @param {Blob} blob
+ * @param {string} filename
+ */
+const downloadBlob = (blob, filename) => {
+    const objURL = URL.createObjectURL(blob);
+    downloadHref(objURL, filename);
+    setTimeout(() => URL.revokeObjectURL(objURL));
+};
+/**
+ * 将指定数据格式通过 A 链接的方式下载
+ * @param {AnyObject | AnyObject[]} data
+ * @param {FileType} fileType 支持 json/csv/xls/xlsx 四种格式
+ * @param {string} filename
+ * @param {string[]} [headers]
+ */
+const downloadData = (data, fileType, filename, headers) => {
+    filename = filename.replace(`.${fileType}`, '') + `.${fileType}`;
+    if (fileType === 'json') {
+        const blob = new Blob([JSON.stringify(data, null, 4)]);
+        downloadBlob(blob, filename);
+    }
+    else {
+        // xlsx实际生成的也为csv，仅后缀名名不同
+        if (!headers || !headers.length)
+            throw new Error('未传入表头数据');
+        if (!Array.isArray(data))
+            throw new Error('data error! expected array!');
+        const headerStr = headers.join(',') + '\n';
+        let bodyStr = '';
+        data.forEach(row => {
+            // \t防止数字被科学计数法显示
+            bodyStr += Object.values(row).join(',\t') + ',\n';
+        });
+        const MIMETypes = {
+            csv: 'text/csv',
+            xls: 'application/vnd.ms-excel',
+            xlsx: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'
+        };
+        // encodeURIComponent解决中文乱码
+        const href = 'data:' + MIMETypes[fileType] + ';charset=utf-8,\ufeff' + encodeURIComponent(headerStr + bodyStr);
+        downloadHref(href, filename);
+    }
+};
+
+export { downloadBlob, downloadData, downloadHref, downloadURL };

package/lib/es/easing.js

@@ -0,0 +1,38 @@
+/*!
+ * sculp-js v0.0.1
+ * (c) 2023-2023 chandq
+ * Released under the MIT License.
+ */
+
+import bezier from 'bezier-easing';
+import { isArray } from './type.js';
+
+// @ref https://cubic-bezier.com/
+const easingDefines = {
+    linear: [0, 0, 1, 1],
+    ease: [0.25, 0.1, 0.25, 1],
+    'ease-in': [0.42, 0, 1, 1],
+    'ease-out': [0, 0, 0.58, 1],
+    'ease-in-out': [0.42, 0, 0.58, 1]
+};
+/**
+ * 缓冲函数化，用于 js 计算缓冲进度
+ * @param {EasingNameOrDefine} [name=linear]
+ * @returns {EasingFunction}
+ */
+function easingFunctional(name) {
+    let fn;
+    if (isArray(name)) {
+        fn = bezier(...name);
+    }
+    else {
+        const define = easingDefines[name];
+        if (!define) {
+            throw new Error(`${name} 缓冲函数未定义`);
+        }
+        fn = bezier(...define);
+    }
+    return (input) => fn(Math.max(0, Math.min(input, 1)));
+}
+
+export { easingFunctional };

package/lib/es/file.js

@@ -0,0 +1,28 @@
+/*!
+ * sculp-js v0.0.1
+ * (c) 2023-2023 chandq
+ * Released under the MIT License.
+ */
+
+/**
+ * 选择本地文件
+ * @param {function} changeCb 选择文件回调
+ * @return {*}
+ */
+function chooseLocalFile({ accept }, changeCb) {
+    const inputObj = document.createElement('input');
+    inputObj.setAttribute('id', String(Date.now()));
+    inputObj.setAttribute('type', 'file');
+    inputObj.setAttribute('style', 'visibility:hidden');
+    inputObj.setAttribute('accept', accept);
+    document.body.appendChild(inputObj);
+    inputObj.click();
+    // @ts-ignore
+    inputObj.onchange = (e) => {
+        changeCb(e.target.files);
+        setTimeout(() => document.body.removeChild(inputObj));
+    };
+    return inputObj;
+}
+
+export { chooseLocalFile };

package/lib/es/index.js

@@ -0,0 +1,35 @@
+/*!
+ * sculp-js v0.0.1
+ * (c) 2023-2023 chandq
+ * Released under the MIT License.
+ */
+
+import * as array from './array.js';
+export { array };
+import * as clipboard from './clipboard.js';
+export { clipboard };
+import * as cookie from './cookie.js';
+export { cookie };
+import * as date from './date.js';
+export { date };
+import * as dom from './dom.js';
+export { dom };
+import * as download from './download.js';
+export { download };
+import * as object from './object.js';
+export { object };
+import * as path from './path.js';
+export { path };
+import * as qs from './qs.js';
+export { qs };
+import * as string from './string.js';
+export { string };
+import * as type from './type.js';
+export { type };
+import * as url from './url.js';
+export { url };
+import * as async from './async.js';
+export { async };
+import * as file from './file.js';
+export { file };
+export { genCanvasWM } from './watermark.js';

package/lib/es/object.js

@@ -0,0 +1,228 @@
+/*!
+ * sculp-js v0.0.1
+ * (c) 2023-2023 chandq
+ * Released under the MIT License.
+ */
+
+import typeIs, { isObject, isUndefined, isArray } from './type.js';
+
+/**
+ * 判断对象是否为纯对象
+ * @param {object} obj
+ * @returns {boolean}
+ */
+const isPlainObject = (obj) => {
+    if (!isObject(obj))
+        return false;
+    const proto = Object.getPrototypeOf(obj);
+    // 对象无原型
+    if (!proto)
+        return true;
+    // 是否对象直接实例
+    return proto === Object.prototype;
+};
+/**
+ * 判断对象内是否有该静态属性
+ * @param {object} obj
+ * @param {string} key
+ * @returns {boolean}
+ */
+const objectHas = (obj, key) => Object.prototype.hasOwnProperty.call(obj, key);
+/**
+ * 遍历对象，返回 false 中断遍历
+ * @param {O} obj
+ * @param {(val: O[keyof O], key: keyof O) => (boolean | void)} iterator
+ */
+const objectEach = (obj, iterator) => {
+    for (const key in obj) {
+        if (!objectHas(obj, key))
+            continue;
+        if (iterator(obj[key], key) === false)
+            break;
+    }
+};
+/**
+ * 异步遍历对象，返回 false 中断遍历
+ * @param {O} obj
+ * @param {(val: O[keyof O], key: keyof O) => (boolean | void)} iterator
+ */
+async function objectEachAsync(obj, iterator) {
+    for (const key in obj) {
+        if (!objectHas(obj, key))
+            continue;
+        if ((await iterator(obj[key], key)) === false)
+            break;
+    }
+}
+/**
+ * 对象映射
+ * @param {O} obj
+ * @param {(val: O[keyof O], key: Extract<keyof O, string>) => any} iterator
+ * @returns {Record<Extract<keyof O, string>, T>}
+ */
+function objectMap(obj, iterator) {
+    const obj2 = {};
+    for (const key in obj) {
+        if (!objectHas(obj, key))
+            continue;
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        obj2[key] = iterator(obj[key], key);
+    }
+    return obj2;
+}
+/**
+ * 对象提取
+ * @param {O} obj
+ * @param {K} keys
+ * @returns {Pick<O, ArrayElements<K>>}
+ */
+function objectPick(obj, keys) {
+    const obj2 = {};
+    objectEach(obj, (v, k) => {
+        if (keys.includes(k)) {
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+            // @ts-ignore
+            obj2[k] = v;
+        }
+    });
+    return obj2;
+}
+/**
+ * 对象祛除
+ * @param {O} obj
+ * @param {K} keys
+ * @returns {Pick<O, ArrayElements<K>>}
+ */
+function objectOmit(obj, keys) {
+    const obj2 = {};
+    objectEach(obj, (v, k) => {
+        if (!keys.includes(k)) {
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+            // @ts-ignore
+            obj2[k] = v;
+        }
+    });
+    return obj2;
+}
+const merge = (map, source, target) => {
+    if (isUndefined(target))
+        return source;
+    const sourceType = typeIs(source);
+    const targetType = typeIs(target);
+    if (sourceType !== targetType) {
+        if (isArray(target))
+            return merge(map, [], target);
+        if (isObject(target))
+            return merge(map, {}, target);
+        return target;
+    }
+    // 朴素对象
+    if (isPlainObject(target)) {
+        const exist = map.get(target);
+        if (exist)
+            return exist;
+        map.set(target, source);
+        objectEach(target, (val, key) => {
+            source[key] = merge(map, source[key], val);
+        });
+        return source;
+    }
+    // 数组
+    else if (isArray(target)) {
+        const exist = map.get(target);
+        if (exist)
+            return exist;
+        map.set(target, source);
+        target.forEach((val, index) => {
+            source[index] = merge(map, source[index], val);
+        });
+        return source;
+    }
+    return target;
+};
+/**
+ * 对象合并，返回原始对象
+ * @param {ObjectAssignItem} source
+ * @param {ObjectAssignItem | undefined} targets
+ * @returns {R}
+ */
+const objectAssign = (source, ...targets) => {
+    const map = new Map();
+    for (let i = 0; i < targets.length; i++) {
+        const target = targets[i];
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        source = merge(map, source, target);
+    }
+    map.clear();
+    return source;
+};
+/**
+ * 对象填充
+ * @param {Partial<R>} source
+ * @param {Partial<R>} target
+ * @param {(s: Partial<R>, t: Partial<R>, key: keyof R) => boolean} fillable
+ * @returns {R}
+ */
+const objectFill = (source, target, fillable) => {
+    const _fillable = fillable || ((source, target, key) => source[key] === undefined);
+    objectEach(target, (val, key) => {
+        if (_fillable(source, target, key)) {
+            source[key] = val;
+        }
+    });
+    return source;
+};
+function objectGet(obj, path, strict = false) {
+    path = path.replace(/\[(\w+)\]/g, '.$1');
+    path = path.replace(/^\./, '');
+    const keyArr = path.split('.');
+    let tempObj = obj;
+    let i = 0;
+    for (let len = keyArr.length; i < len - 1; ++i) {
+        const key = keyArr[i];
+        if (key in tempObj) {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-assignment
+            tempObj = tempObj[key];
+        }
+        else {
+            tempObj = undefined;
+            if (strict) {
+                throw new Error('[berry/js-utils/object] objectGet path 路径不正确');
+            }
+            break;
+        }
+    }
+    return {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        p: tempObj,
+        k: tempObj ? keyArr[i] : undefined,
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-assignment
+        v: tempObj ? tempObj[keyArr[i]] : undefined
+    };
+}
+/**
+ * 深拷贝堪称完全体 即：任何类型的数据都会被深拷贝
+ * @param {AnyObject | AnyArray} obj
+ * @param {WeakMap} map
+ * @return {AnyObject | AnyArray}
+ */
+function cloneDeep(obj, map = new WeakMap()) {
+    if (obj instanceof Date)
+        return new Date(obj);
+    if (obj instanceof RegExp)
+        return new RegExp(obj);
+    if (map.has(obj)) {
+        return map.get(obj);
+    }
+    const allDesc = Object.getOwnPropertyDescriptors(obj);
+    const cloneObj = Object.create(Object.getPrototypeOf(obj), allDesc);
+    map.set(obj, cloneObj);
+    for (const key of Reflect.ownKeys(obj)) {
+        const value = obj[key];
+        cloneObj[key] = value instanceof Object && typeof value !== 'function' ? cloneDeep(value, map) : value;
+    }
+    return cloneObj;
+}
+
+export { cloneDeep, isPlainObject, objectAssign, objectEach, objectEachAsync, objectFill, objectGet, objectHas, objectMap, objectAssign as objectMerge, objectOmit, objectPick };

package/lib/es/path.js

@@ -0,0 +1,63 @@
+/*!
+ * sculp-js v0.0.1
+ * (c) 2023-2023 chandq
+ * Released under the MIT License.
+ */
+
+/**
+ * 标准化路径
+ * @param {string} path
+ * @returns {string}
+ */
+const pathNormalize = (path) => {
+    const slicees = path
+        .replace(/\\/g, '/')
+        .replace(/\/{2,}/g, '/')
+        .replace(/\.{3,}/g, '..')
+        .replace(/\/\.\//g, '/')
+        .split('/')
+        .map(point => point.trim());
+    const isCurrentSlice = (slice) => slice === '.';
+    const isParentSlice = (slice) => slice === '..';
+    const points = [];
+    let inPoints = false;
+    const push = (point) => {
+        points.push(point);
+    };
+    const back = () => {
+        if (points.length === 0)
+            return;
+        const lastSlice = points[points.length - 1];
+        if (isParentSlice(lastSlice)) {
+            points.push('..');
+        }
+        else {
+            points.pop();
+        }
+    };
+    slicees.forEach(slice => {
+        const isCurrent = isCurrentSlice(slice);
+        const isParent = isParentSlice(slice);
+        // 未进入实际路径
+        if (!inPoints) {
+            push(slice);
+            inPoints = !isCurrent && !isParent;
+            return;
+        }
+        if (isCurrent)
+            return;
+        if (isParent)
+            return back();
+        push(slice);
+    });
+    return points.join('/');
+};
+/**
+ * 路径合并
+ * @param {string} from
+ * @param {string} to
+ * @returns {string}
+ */
+const pathJoin = (from, ...to) => pathNormalize([from, ...to].join('/'));
+
+export { pathJoin, pathNormalize };

package/lib/es/qs.js

@@ -0,0 +1,68 @@
+/*!
+ * sculp-js v0.0.1
+ * (c) 2023-2023 chandq
+ * Released under the MIT License.
+ */
+
+import { objectEach } from './object.js';
+import { isUndefined, isArray, isString, isNumber, isBoolean, isDate } from './type.js';
+
+/**
+ * 解析查询参数，内部使用的是浏览器内置的 URLSearchParams 进行处理
+ * @param {string} queryString
+ * @returns {Params}
+ */
+const qsParse = (queryString) => {
+    const params = new URLSearchParams(queryString);
+    const result = {};
+    for (const [key, val] of params.entries()) {
+        if (isUndefined(result[key])) {
+            result[key] = val;
+            continue;
+        }
+        if (isArray(result[key])) {
+            continue;
+        }
+        result[key] = params.getAll(key);
+    }
+    return result;
+};
+const defaultReplacer = (val) => {
+    if (isString(val))
+        return val;
+    if (isNumber(val))
+        return String(val);
+    if (isBoolean(val))
+        return val ? 'true' : 'false';
+    if (isDate(val))
+        return val.toISOString();
+    return null;
+};
+/**
+ * 字符化查询对象，内部使用的是浏览器内置的 URLSearchParams 进行处理
+ * @param {LooseParams} query
+ * @param {Replacer} replacer
+ * @returns {string}
+ */
+const qsStringify = (query, replacer = defaultReplacer) => {
+    const params = new URLSearchParams();
+    objectEach(query, (val, key) => {
+        if (isArray(val)) {
+            val.forEach(i => {
+                const replaced = replacer(i);
+                if (replaced === null)
+                    return;
+                params.append(key.toString(), replaced);
+            });
+        }
+        else {
+            const replaced = replacer(val);
+            if (replaced === null)
+                return;
+            params.set(key.toString(), replaced);
+        }
+    });
+    return params.toString();
+};
+
+export { qsParse, qsStringify };