dlsjs 1.0.5 → 1.0.6

package/src/Browser/Screen.js

@@ -1,175 +0,0 @@
-/**
- * 切换全屏状态
- * 如果当前处于全屏模式则退出，否则进入全屏模式
- * 时间复杂度O(1)：直接调用浏览器API，无循环操作
- *
- * @param {HTMLElement} [element=document.documentElement] - 要设置为全屏的元素，默认为整个文档
- * @returns {boolean} 操作是否成功执行
- *
- * @example
- * // 切换整个文档的全屏状态
- * toggleFullscreen();
- *
- * // 切换指定元素的全屏状态
- * toggleFullscreen(document.getElementById('myElement'));
- */
-export function toggleFullscreen(element = document.documentElement) {
-    if (!element || !(element instanceof HTMLElement)) {
-        console.warn('dlsjs: toggleFullscreen 参数必须是有效的HTML元素');
-        return false;
-    }
-
-    if (isFullscreenActive()) {
-        return exitFullscreen();
-    } else {
-        return requestFullscreen(element);
-    }
-}
-
-/**
- * 请求进入全屏模式
- * 时间复杂度O(1)：直接调用浏览器API，无循环操作
- *
- * @param {HTMLElement} element - 要设置为全屏的元素
- * @returns {boolean} 操作是否成功发起
- *
- * @example
- * requestFullscreen(document.getElementById('myElement'));
- */
-export function requestFullscreen(element) {
-    if (!element || !(element instanceof HTMLElement)) {
-        console.warn('dlsjs: requestFullscreen 参数必须是有效的HTML元素');
-        return false;
-    }
-
-    try {
-        // 处理不同浏览器的全屏API
-        const requestMethod =
-            element.requestFullscreen ||
-            element.webkitRequestFullscreen ||
-            element.mozRequestFullScreen ||
-            element.msRequestFullscreen;
-
-        if (requestMethod) {
-            requestMethod.call(element);
-            return true;
-        } else {
-            console.warn('dlsjs: 当前浏览器不支持全屏API');
-            return false;
-        }
-    } catch (error) {
-        console.error('dlsjs: 全屏请求失败:', error);
-        return false;
-    }
-}
-
-/**
- * 退出全屏模式
- * 时间复杂度O(1)：直接调用浏览器API，无循环操作
- *
- * @returns {boolean} 操作是否成功发起
- *
- * @example
- * exitFullscreen();
- */
-export function exitFullscreen() {
-    try {
-        // 处理不同浏览器的退出全屏API
-        const exitMethod =
-            document.exitFullscreen ||
-            document.webkitExitFullscreen ||
-            document.mozCancelFullScreen ||
-            document.msExitFullscreen;
-
-        if (exitMethod) {
-            exitMethod.call(document);
-            return true;
-        } else {
-            console.warn('dlsjs: 当前浏览器不支持退出全屏API');
-            return false;
-        }
-    } catch (error) {
-        console.error('dlsjs: 退出全屏失败:', error);
-        return false;
-    }
-}
-
-/**
- * 检查当前是否处于全屏模式
- * 时间复杂度O(1)：直接访问浏览器属性，无循环操作
- *
- * @returns {boolean} 当前是否处于全屏模式
- *
- * @example
- * if (isFullscreenActive()) {
- *     console.log('当前处于全屏模式');
- * }
- */
-export function isFullscreenActive() {
-    return !!(
-        document.fullscreenElement ||
-        document.webkitFullscreenElement ||
-        document.mozFullScreenElement ||
-        document.msFullscreenElement
-    );
-}
-
-/**
- * 获取当前全屏元素
- * 时间复杂度O(1)：直接访问浏览器属性，无循环操作
- *
- * @returns {HTMLElement|null} 当前全屏元素，如果没有则返回null
- *
- * @example
- * const fullscreenElement = getFullscreenElement();
- */
-export function getFullscreenElement() {
-    return (
-        document.fullscreenElement ||
-        document.webkitFullscreenElement ||
-        document.mozFullScreenElement ||
-        document.msFullscreenElement ||
-        null
-    );
-}
-
-/**
- * 添加全屏状态变化监听器
- * 时间复杂度O(1)：直接添加事件监听器，无循环操作
- *
- * @param {Function} callback - 状态变化时的回调函数
- * @returns {Function} 移除监听器的函数
- *
- * @example
- * const removeListener = addFullscreenChangeListener(() => {
- *     console.log('全屏状态发生变化');
- * });
- *
- * // 稍后移除监听器
- * removeListener();
- */
-export function addFullscreenChangeListener(callback) {
-    if (typeof callback !== 'function') {
-        console.warn('dlsjs: addFullscreenChangeListener 参数必须是函数');
-        return () => {};
-    }
-
-    const eventName =
-        'fullscreenchange' in document ? 'fullscreenchange' :
-        'webkitfullscreenchange' in document ? 'webkitfullscreenchange' :
-        'mozfullscreenchange' in document ? 'mozfullscreenchange' :
-        'MSFullscreenChange' in document ? 'MSFullscreenChange' : null;
-
-    if (!eventName) {
-        console.warn('dlsjs: 当前浏览器不支持全屏变化事件');
-        return () => {};
-    }
-
-    const handler = () => callback(isFullscreenActive());
-    document.addEventListener(eventName, handler);
-
-    // 返回移除监听器的函数
-    return () => {
-        document.removeEventListener(eventName, handler);
-    };
-}

package/src/Browser/Timer.js

@@ -1,99 +0,0 @@
-/**
- * 等待一个结果为真的情况执行
- */
-
-export function waitValue (valueGetter, timeout = 10000, freq = 100) {
-    return new Promise((resolve,reject) => {
-        let count = 0
-        let timerId = setInterval(() => {
-            if(count*freq > timeout) {
-                clearInterval(timerId)
-                reject('等待超时')
-            }
-            if(valueGetter()) {
-                clearInterval(timerId)
-                resolve(valueGetter())
-            }
-            count++
-        }, freq)
-    })
-}
-
-/**
- * 等待固定毫秒数
- * @param ms
- */
-export async function waitMS (ms) {
-    return new Promise(resolve => {
-        setTimeout(resolve, ms)
-    })
-}
-
-/**
- * 一个变化代理，如果一段时间内反复横跳，则取最后，相当于节流防抖的赋值代理版本。
- * 应用场景：解决loading状态在多处频繁变化
- */
-export function lazyChange (obj, timeout = 100) {
-    let timer = null
-    const handler = {
-        set: (target, key, value) => {
-            if(!timer) target[key] = value
-            else clearTimeout(timer)
-            timer = setTimeout(() => {target[key] = value}, timeout)
-            return true
-        }
-    }
-    return new Proxy(obj, handler)
-}
-
-/**
- * async防抖函数，接收一个async函数，返回节流的async函数
- * 先执行一次，timeout毫秒内在发生调用则忽视，timeout后才可继续调用
- */
-export function throttleAsync(func, timeout = 100) {
-    let lastTime = 0
-    return async function(...args) {
-        const now = Date.now()
-        if(now - lastTime < timeout) {
-            return
-        }
-        lastTime = now
-        return await func(...args)
-    }
-}
-
-/**
- * 接收一个async函数，返回新的async函数
- * 至少freq毫秒后触发该函数，freq内再次触发，取消前一次触发，直到freq毫秒内没有触发，正式执行这个函数
- */
-export function debounceAsync(func, wait = 100) {
-    let timer = null
-    return function(...args) {
-        if(timer) clearTimeout(timer)
-        timer = setTimeout(() => {
-            func(...args)
-        }, wait)
-    }
-}
-
-/**
- * 轮询工具
- */
-export class Poll {
-    constructor() {
-        this.timer = null
-        this.func = () => {}
-        this.freq = 1000
-    }
-    init() {
-        if(this.timer) return
-        this.func()
-        this.timer = setInterval(() => {
-            this.func()
-        },this.freq)
-    }
-    destroy() {
-        clearInterval(this.timer)
-        this.timer = null
-    }
-}

package/src/ES/Chain.js

@@ -1,62 +0,0 @@
-import * as r from 'ramda'
-
-/**
- * 代理函数执行
- * @type {{get: ((function(*, *, *): (function(): *))|*)}}
- */
-const handler = {
-    get: function (target, p, receiver) {
-        if (!r.isNil(target[p])) {
-            // 使用本身方法
-            if (r.is(Function, target[p])) {
-                return (...arg) => {
-                    let result = target[p].call(target, ...arg)
-                    return pack(result)
-                }
-            }
-            // 使用本身属性
-            else {
-                return pack(target[p])
-            }
-        }
-        // 使用ramda方法
-        if (r[p] instanceof Function) {
-            let func;
-            if (r[p].length > 1) {
-                const paramList = new Array(r[p].length - 1).fill(r.__)
-                func = r[p](...paramList, target)
-            } else {
-                func = () => r[p](target)
-            }
-            return (...args) => {
-                let result = func(...args)
-                return pack(result)
-            }
-        }
-        return target[p]
-    }
-}
-
-/**
- * 数据是否为数组或者对象
- */
-function isAO(data) {
-    return ['[object Object]', '[object Array]'].includes(Object.prototype.toString.call(data))
-}
-
-/**
- * 如果是对象或数组则包装成proxy
- */
-function pack(data) {
-    if (isAO(data)) {
-        return new Proxy(data, handler)
-    } else {
-        return data
-    }
-}
-
-export function Chain(data) {
-    return pack(data)
-}
-
-export default Chain

package/src/ES/Const.js

@@ -1,24 +0,0 @@
-import {treeFind} from "./Tree";
-
-export const ENLetters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
-
-export class DLS {
-    constructor() {
-        this.treeFind = treeFind
-    }
-}
-
-export function generateRandomId() {
-    const chars = 'abcdefghijklmnopqrstuvwxyz0123456789';
-    let result = '';
-
-    // 使用Web Crypto API获取安全的随机值
-    const randomValues = new Uint8Array(8);
-    crypto.getRandomValues(randomValues);
-
-    for (let i = 0; i < 8; i++) {
-        result += chars[randomValues[i] % chars.length];
-    }
-
-    return result;
-}

package/src/ES/Judgment.js

@@ -1,184 +0,0 @@
-import {isEmpty, isNil, type} from 'ramda'
-import {RW} from "./QRW";
-/**
- * 区间判断
- * @param value
- * @param range
- * @return {boolean|void|*}
- *
- * @example
- * isRangeIn(55,'[50,60]')
- * 中括号开区间，小括号闭区间，大括号枚举匹配，直接填入数值判断等于
- */
-export const isRangeIn = function (value, range) {
-    if(typeof range === 'number') range = range.toString()
-    if(!range) return false // range为空时默认错误
-    if(!value && value !== 0) return false // value为空时默认错误
-    if(!isNaN(value)) value = Number(value) // value不为number时强转一下
-    else {
-        console.error('isRangeIn first param "value" is NaN')
-        return false
-    }
-    let isContainMin = false
-    let isContainMax = false
-    let isGTMin = false
-    let isLTMax = false
-    // 纯数字时相等为真
-    if(!isNaN(Number(range))) return value === Number(range)
-    // 花括弧时，包含为真
-    if(range.includes('{') && range.includes('}')) {
-        let arrString = range.replace(/\{|}/g,'')
-        let arr = arrString.split(',').map(item => {
-            return Number(item)
-        })
-        return arr.includes(value)
-    }
-    // 位运算+幂运算（判断第几位是1）
-    if(range.includes('&pow')) {
-        let string = range.replace(/(&pow)/g,'')
-        return !!(value&Math.pow(2,Number(string) - 1))
-    }
-    // 位运算（与）
-    if(range.includes('&')) {
-        let string = range.replace(/(&)/g,'')
-        return !!(value&Number(string))
-    }
-    // 开闭区间，运算
-    let rangeArr = range.split(',')
-    if(rangeArr[0].includes('[')) isContainMin = true
-    if(rangeArr[1].includes(']')) isContainMax = true
-    let min = rangeArr[0].replace(/\[|]|\(|\)/g,'') || -Infinity
-    let max = rangeArr[1].replace(/\[|]|\(|\)/g,'') || Infinity
-    if(isContainMin) {
-        isGTMin = value >= min
-    }else {
-        isGTMin = value > min
-    }
-    if(isContainMax) {
-        isLTMax = value <= max
-
-    }else {
-        isLTMax = value < max
-    }
-    return isLTMax && isGTMin
-}
-
-/**
- * 判断一个对象是否符合要求
- * @param {{key,value,condition,prop,eval,enum,dateFormat,must,should,matchFuncName}} config
- * @param {{}} data
- * @param {{}} [myFuncMap]
- * @return {boolean|*}
- */
-export function matchRules(config, data) {
-    if(config.must) {
-        return checkMust(config.must, data)
-    }
-    if(config.should) {
-        return checkShould(config.should, data)
-    }
-    if(config.condition) {
-        let left = config.left
-        let right = config.right
-        if(config.leftKey) {
-            left = RW(data)[config.leftKey]
-        }
-        if(config.rightKey) {
-            right = RW(data)[config.rightKey]
-        }
-        if(config.condition === 'eq') {
-            return left === right
-        }
-        if(config.condition === 'ne') {
-            return left !== right
-        }
-        if(config.condition === 'lt') {
-            return left < right
-        }
-        if(config.condition === 'le') {
-            return left <= right
-        }
-        if(config.condition === 'gt') {
-            return left > right
-        }
-        if(config.condition === 'ge') {
-            return left >= right
-        }
-        if(config.condition === 'in') {
-            if(['String', 'Array'].includes(type(right))) {
-                return right?.includes(left)
-            }else {
-                console.error(`${right} is not String|Array`)
-                return false
-            }
-        }
-        if(config.condition === 'nin') {
-            if(['String', 'Array'].includes(type(right))) {
-                return !right?.includes(left)
-            }else {
-                console.error(`${right} is not String|Array`)
-                return false
-            }
-        }
-        if(config.condition === 'has') {
-            if(['String', 'Array'].includes(type(left))) {
-                return left?.includes(right)
-            }else {
-                console.error(`${left} is not String|Array`)
-                return false
-            }
-        }
-        if(config.condition === 'nhas') {
-            if(['String', 'Array'].includes(type(left))) {
-                return !left?.includes(right)
-            }else {
-                console.error(`${left} is not String|Array`)
-                return false
-            }
-        }
-        if(config.condition === 'notNull') {
-            return !isNil(left) && !isEmpty(left)
-        }
-        if(config.condition === 'isNull') {
-            return isNil(left) || isEmpty(left)
-        }
-        if(config.condition === 'any') {
-            return true
-        }
-    }
-    return true
-}
-
-/**
- * 通用条件判断must
- */
-export function checkMust(must, row) {
-    let result = []
-    for(let item of must) {
-        result.push(matchRules(item, row))
-    }
-    return !result.includes(false)
-}
-
-/**
- * 通用条件判断should
- */
-export function checkShould(should, row) {
-    let result = []
-    for(let item of should) {
-        result.push(matchRules(item, row))
-    }
-    return result.includes(true)
-}
-
-/**
- * 类型判断
- */
-export function isType(type, target) {
-    let typeList = type.split(',')
-    let result = []
-    for(let type of typeList) {
-        result.push(Object.prototype.toString.call(target) === `[object ${type}]`)
-    }
-    return result.includes(true)
-}