sculp-js 0.0.1

package/lib/cjs/download.js

@@ -0,0 +1,82 @@
+/*!
+ * sculp-js v0.0.1
+ * (c) 2023-2023 chandq
+ * Released under the MIT License.
+ */
+
+'use strict';
+
+var url = require('./url.js');
+
+/**
+ * 通过打开新窗口的方式下载
+ * @param {string} url
+ * @param {LooseParams} params
+ */
+const downloadURL = (url$1, params) => {
+    window.open(params ? url.urlSetParams(url$1, params) : url$1);
+};
+/**
+ * 通过 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);
+    }
+};
+
+exports.downloadBlob = downloadBlob;
+exports.downloadData = downloadData;
+exports.downloadHref = downloadHref;
+exports.downloadURL = downloadURL;

package/lib/cjs/easing.js

@@ -0,0 +1,40 @@
+/*!
+ * sculp-js v0.0.1
+ * (c) 2023-2023 chandq
+ * Released under the MIT License.
+ */
+
+'use strict';
+
+var bezier = require('bezier-easing');
+var type = require('./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 (type.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)));
+}
+
+exports.easingFunctional = easingFunctional;

package/lib/cjs/file.js

@@ -0,0 +1,30 @@
+/*!
+ * sculp-js v0.0.1
+ * (c) 2023-2023 chandq
+ * Released under the MIT License.
+ */
+
+'use strict';
+
+/**
+ * 选择本地文件
+ * @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;
+}
+
+exports.chooseLocalFile = chooseLocalFile;

package/lib/cjs/index.js

@@ -0,0 +1,41 @@
+/*!
+ * sculp-js v0.0.1
+ * (c) 2023-2023 chandq
+ * Released under the MIT License.
+ */
+
+'use strict';
+
+var array = require('./array.js');
+var clipboard = require('./clipboard.js');
+var cookie = require('./cookie.js');
+var date = require('./date.js');
+var dom = require('./dom.js');
+var download = require('./download.js');
+var object = require('./object.js');
+var path = require('./path.js');
+var qs = require('./qs.js');
+var string = require('./string.js');
+var type = require('./type.js');
+var url = require('./url.js');
+var async = require('./async.js');
+var file = require('./file.js');
+var watermark = require('./watermark.js');
+
+
+
+exports.array = array;
+exports.clipboard = clipboard;
+exports.cookie = cookie;
+exports.date = date;
+exports.dom = dom;
+exports.download = download;
+exports.object = object;
+exports.path = path;
+exports.qs = qs;
+exports.string = string;
+exports.type = type;
+exports.url = url;
+exports.async = async;
+exports.file = file;
+exports.genCanvasWM = watermark.genCanvasWM;

package/lib/cjs/object.js

@@ -0,0 +1,241 @@
+/*!
+ * sculp-js v0.0.1
+ * (c) 2023-2023 chandq
+ * Released under the MIT License.
+ */
+
+'use strict';
+
+var type = require('./type.js');
+
+/**
+ * 判断对象是否为纯对象
+ * @param {object} obj
+ * @returns {boolean}
+ */
+const isPlainObject = (obj) => {
+    if (!type.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 (type.isUndefined(target))
+        return source;
+    const sourceType = type.default(source);
+    const targetType = type.default(target);
+    if (sourceType !== targetType) {
+        if (type.isArray(target))
+            return merge(map, [], target);
+        if (type.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 (type.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;
+}
+
+exports.cloneDeep = cloneDeep;
+exports.isPlainObject = isPlainObject;
+exports.objectAssign = objectAssign;
+exports.objectEach = objectEach;
+exports.objectEachAsync = objectEachAsync;
+exports.objectFill = objectFill;
+exports.objectGet = objectGet;
+exports.objectHas = objectHas;
+exports.objectMap = objectMap;
+exports.objectMerge = objectAssign;
+exports.objectOmit = objectOmit;
+exports.objectPick = objectPick;

package/lib/cjs/path.js

@@ -0,0 +1,66 @@
+/*!
+ * sculp-js v0.0.1
+ * (c) 2023-2023 chandq
+ * Released under the MIT License.
+ */
+
+'use strict';
+
+/**
+ * 标准化路径
+ * @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('/'));
+
+exports.pathJoin = pathJoin;
+exports.pathNormalize = pathNormalize;

package/lib/cjs/qs.js

@@ -0,0 +1,71 @@
+/*!
+ * 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');
+
+/**
+ * 解析查询参数，内部使用的是浏览器内置的 URLSearchParams 进行处理
+ * @param {string} queryString
+ * @returns {Params}
+ */
+const qsParse = (queryString) => {
+    const params = new URLSearchParams(queryString);
+    const result = {};
+    for (const [key, val] of params.entries()) {
+        if (type.isUndefined(result[key])) {
+            result[key] = val;
+            continue;
+        }
+        if (type.isArray(result[key])) {
+            continue;
+        }
+        result[key] = params.getAll(key);
+    }
+    return result;
+};
+const defaultReplacer = (val) => {
+    if (type.isString(val))
+        return val;
+    if (type.isNumber(val))
+        return String(val);
+    if (type.isBoolean(val))
+        return val ? 'true' : 'false';
+    if (type.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();
+    object.objectEach(query, (val, key) => {
+        if (type.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();
+};
+
+exports.qsParse = qsParse;
+exports.qsStringify = qsStringify;

package/lib/cjs/string.js

@@ -0,0 +1,134 @@
+/*!
+ * sculp-js v0.0.1
+ * (c) 2023-2023 chandq
+ * Released under the MIT License.
+ */
+
+'use strict';
+
+/**
+ * 将字符串转换为驼峰格式
+ * @param {string} string
+ * @param {boolean} [bigger] 是否大写第一个字母
+ * @returns {string}
+ */
+const stringCamelCase = (string, bigger) => {
+    let string2 = string;
+    if (bigger) {
+        string2 = string.replace(/^./, origin => origin.toUpperCase());
+    }
+    const HUMP_RE = /[\s_-](.)/g;
+    return string2.replace(HUMP_RE, (orign, char) => char.toUpperCase());
+};
+/**
+ * 将字符串转换为连字格式
+ * @param {string} string
+ * @param {string} [separator] 分隔符，默认是"-"（短横线）
+ * @returns {string}
+ */
+const stringKebabCase = (string, separator = '-') => {
+    const string2 = string.replace(/^./, origin => origin.toLowerCase());
+    return string2.replace(/[A-Z]/g, origin => `${separator}${origin.toLowerCase()}`);
+};
+const STRING_ARABIC_NUMERALS = '0123456789';
+const STRING_LOWERCASE_ALPHA = 'abcdefghijklmnopqrstuvwxyz';
+const STRING_UPPERCASE_ALPHA = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
+const placeholderRE = /%[%sdo]/g;
+/**
+ * 字符串格式化
+ * @example
+ * ```js
+ * stringFormat("My name is %s.", "zhangsan")
+ * // => "My name is zhangsan."
+ * ```
+ * @param {string} string 字符串模板，使用 %s 表示字符串，%d 表示数值，%o 表示对象，%% 表示百分号，参考 console.log
+ * @param args
+ * @returns {string}
+ */
+const stringFormat = (string, ...args) => {
+    let index = 0;
+    const result = string.replace(placeholderRE, (origin) => {
+        const arg = args[index++];
+        switch (origin) {
+            case '%%':
+                index--;
+                return '%';
+            default:
+            case '%s':
+                return String(arg);
+            case '%d':
+                return String(Number(arg));
+            case '%o':
+                return JSON.stringify(arg);
+        }
+    });
+    return [result, ...args.splice(index).map(String)].join(' ');
+};
+const ev = (expression, data) => {
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-implied-eval,@typescript-eslint/no-unsafe-return
+        return new Function('with(arguments[0]){' +
+            /****/ `if(arguments[0].${expression} === undefined)throw "";` +
+            /****/
+            /****/ `return String(arguments[0].${expression})` +
+            '}')(data);
+    }
+    catch (err) {
+        throw new SyntaxError(`无法执行表达式：${expression}`);
+    }
+};
+const templateRE = /\${(.*?)}/g;
+/**
+ * 字符串赋值
+ * @example
+ * ```js
+ * stringAssign('My name is ${user}.', { user: 'zhangsan' });
+ * // => "My name is zhangsan."
+ * ```
+ * @param {string} template
+ * @param {AnyObject} data
+ * @returns {string}
+ */
+const stringAssign = (template, data) => {
+    return template.replace(templateRE, (origin, expression) => ev(expression, data));
+};
+/**
+ * 字符串编码 HTML
+ * @example
+ * ```js
+ * stringEscapeHtml('<b>You & Me speak "xixi"</b>')
+ * // => "&lt;b&gt;You &amp; Me speak &quot;xixi&quot;&lt;/b&gt;"
+ * ```
+ * @param {string} html
+ * @returns {string}
+ */
+const stringEscapeHtml = (html) => {
+    const htmlCharRE = /[&<>"]/g;
+    const htmlCharReplacements = {
+        '&': '&amp;',
+        '<': '&lt;',
+        '>': '&gt;',
+        '"': '&quot;'
+    };
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+    return html.replace(htmlCharRE, $0 => htmlCharReplacements[$0]);
+};
+/**
+ * 字符串填充
+ * @param {number} length
+ * @param {string} value
+ * @returns {string}
+ */
+const stringFill = (length, value = ' ') => new Array(length).fill(value).join('');
+
+exports.STRING_ARABIC_NUMERALS = STRING_ARABIC_NUMERALS;
+exports.STRING_LOWERCASE_ALPHA = STRING_LOWERCASE_ALPHA;
+exports.STRING_UPPERCASE_ALPHA = STRING_UPPERCASE_ALPHA;
+exports.stringAssign = stringAssign;
+exports.stringCamelCase = stringCamelCase;
+exports.stringEscapeHtml = stringEscapeHtml;
+exports.stringFill = stringFill;
+exports.stringFormat = stringFormat;
+exports.stringKebabCase = stringKebabCase;