dlsjs 1.0.4 → 1.0.6

package/src/ES/QRW.js

@@ -1,287 +0,0 @@
-import {isNil} from "ramda";
-import {findLeaf} from "./Tree";
-/**
- * 读写扩展，将扩展getter，setter方法，更易于双向绑定的使用
- */
-const ReservedFunction = {
-    /**
-     * 取值时解析JSON字符串为JS对象，赋值后将JS对象序列化回JSON字符串
-     */
-    "JSON": {
-        get: (v) => {
-            try {
-                return JSON.parse(v)
-            }catch (e) {
-                // console.warn(e)
-                return v
-            }
-        },
-        set: (tempSchema, tempKey, tempValue) => {
-            try {
-                tempSchema[tempKey] = JSON.stringify(tempValue)
-                return true
-            }catch (e) {
-                // console.warn(e)
-                tempSchema[tempKey] = '{}'
-                return true
-            }
-        }
-    },
-    /**
-     * 取值时如果为空则创建空数组容器，赋值前如果没有数组容器，则创建数组容器
-     */
-    "Array": {
-        get: (v, tempSchema, tempKey) => {
-            if(!v) tempSchema[tempKey] = []
-            return tempSchema[tempKey]
-        },
-        preSet: (tempSchema, tempKey, tempValue) => {
-            if(!tempSchema) tempSchema = []
-            for(let i = 0; i < Number(tempKey); i++){
-                if(isNil(tempSchema[i])) {
-                    tempSchema[i] = null
-                }
-            }
-            return tempSchema
-        }
-    },
-    /**
-     * 取值时如果上级是对象数组，则调用Array.property.map(item => item[index])
-     * 赋值时则调用Array.property.forEach(item => item[index] = tempValue)
-     */
-    "Item": {
-        get: (v, tempSchema, tempKey) => {
-            if(Array.isArray(tempSchema)) {
-                return tempSchema.map(item => item[tempKey])
-            }else {
-                return tempSchema[tempKey]
-            }
-        },
-        set: (tempSchema, tempKey, tempValue) => {
-            for(let i = 0; i < tempValue.length; i++){
-                if(!isNil(tempValue[i])) {
-                    if(!tempSchema[i]) tempSchema[i] = {}
-                    tempSchema[i][tempKey] = tempValue[i]
-                }
-            }
-            return tempSchema
-        }
-    },
-    /*针对数字与数组 todo 切换A2S*/
-    "ItemString": {
-        get: (v, tempSchema, tempKey) => {
-            if(Array.isArray(tempSchema)) {
-                return tempSchema.map(item => item[tempKey]).toString()
-            }else {
-                return tempSchema[tempKey]
-            }
-        },
-        set: (tempSchema, tempKey, tempValue) => {
-            tempValue = tempValue.split(',')
-            for(let i = 0; i < tempValue.length; i++){
-                if(!tempSchema[i]) tempSchema[i] = {}
-                if(!isNil(tempValue[i])) {
-                    if(!tempSchema[i]) tempSchema[i] = {}
-                    tempSchema[i][tempKey] = tempValue[i]
-                }
-            }
-            return tempSchema
-        }
-    },
-    /*针对数字与数组 todo 切换N2S*/
-    "String": {
-        get: (v) => {
-            return v.toString()
-        },
-        set: (tempSchema, tempKey, tempValue) => {
-            if(typeof tempValue !== 'string') {
-                tempSchema[tempKey] = tempValue.toString()
-            }else {
-                tempSchema[tempKey] = tempValue
-            }
-            return tempSchema
-        }
-    },
-    "Number": {
-        get: (v) => {
-            return Number(v || 0)
-        },
-        set: (tempSchema, tempKey, tempValue) => {
-            tempSchema[tempKey] = Number(tempValue || 0)
-            return tempSchema
-        }
-    },
-    "Boolean": {
-        get: (v) => {
-            if(v === 'true') return true
-            if(v === 'false') return false
-            return !!v
-        },
-        set: (tempSchema, tempKey, tempValue) => {
-            if(tempValue === 'true') tempSchema[tempKey] = true
-            else if(tempValue === 'false') tempSchema[tempKey] = false
-            else tempSchema[tempKey] = !!tempValue
-            return tempSchema
-        }
-    },
-    /**
-     * 取一叉树叶子 todo 赋值未完成
-     */
-    "Leaf": {
-        get: (v, tempSchema, tempKey) => {
-            return findLeaf(tempSchema, tempKey)
-        }
-    }
-}
-
-/**
- * 获取符合openApi中$Ref格式的内容
- * @param {Object} target
- * @param {String} refName
- * @param {String} splitString
- */
-export function queryDefinitionByRef(target, refName, splitString = '/') {
-    let refArray = refName?.split(splitString)
-    refArray.shift() // 抛出"#"
-    let tempSchema = target // 临时参数(每次循环体执行后会改变)，当前内容，随着逐步深入解析改变
-    while(refArray.length > 0) {
-        // todo 是否对Map与Set提供支持，待决定
-        if(!tempSchema) return tempSchema // 开始时做非空判断，防止出现空指针
-        let tempKey = refArray.shift() || '' // 临时参数，取当前key或index
-        if(tempKey === '') return tempSchema // 应对refName为#/的情况
-        let regexRes = /\$([a-zA-Z0-9]+)_(.+)/.exec(tempKey) // 当识别到 $ 开始 _ 结束的正则，开始匹配保留字，做对应处理
-        if(regexRes) {
-            const [matchString, reservedWord, newTempKey] = regexRes
-            tempKey = newTempKey
-            let reversed = ReservedFunction[reservedWord]
-            if(reversed && reversed.get) {
-                tempSchema = reversed.get(tempSchema[tempKey], tempSchema, tempKey)
-                continue
-            }
-        }
-        tempSchema = tempSchema[tempKey]
-    }
-    return tempSchema
-}
-
-/**
- * 设置符合openApi中$Ref格式的内容
- * @param {Object} target
- * @param {String} refName
- * @param {any} value
- * @param {String} splitString
- */
-export function setDefinitionByRef(target, refName, value, splitString = '/') {
-    let refArray = refName?.split(splitString)
-    // refArray.shift() // 不抛出"#"
-    let tempSchema;
-    let tempValue = value;
-    let tempKey = refArray.pop() || '';
-    let preKey;
-    while (refArray.length > 0) {
-        let tempRef = refArray.join('/')
-        tempSchema = queryDefinitionByRef(target, tempRef) // 取当前要赋值的区域
-        preKey = refArray[refArray.length-1] // 赋值区域的键名
-        let regexResPre = /\$([a-zA-Z0-9]+)_(.+)/.exec(preKey) // 当识别到 $ 开始 _ 结束的正则，开始匹配保留字，做对应处理
-        let regexResTemp = /\$([a-zA-Z0-9]+)_(.+)/.exec(tempKey) // 当识别到 $ 开始 _ 结束的正则，开始匹配保留字，做对应处理
-        if(regexResPre) {
-            const [ms, $1, $2] = regexResPre
-            let reversed = ReservedFunction[$1]
-            if(reversed && reversed.preSet) {
-                tempSchema = reversed.preSet(tempSchema, tempKey, tempValue)
-            }
-        }
-        if(regexResTemp) {
-            const [ms, $1, $2] = regexResTemp
-            let reversed = ReservedFunction[$1]
-            if(reversed && reversed.set) {
-                tempValue = reversed.set(tempSchema, $2, tempValue)
-            }else {
-                if(!tempSchema) tempSchema = {}
-                tempSchema[$2] = tempValue
-                tempValue = tempSchema
-            }
-        }else {
-            if(!tempSchema) tempSchema = {}
-            tempSchema[tempKey] = tempValue
-            tempValue = tempSchema
-        }
-        tempKey = preKey;
-        refArray.pop();
-    }
-    return true
-}
-
-/**
- * 读写代理内容
- */
-const handler = {
-    get: (target, key) => {
-        let result;
-        if(typeof key === 'string' && key.includes('#/')) {
-            result = queryDefinitionByRef(target, key)
-        }else {
-            result = target[key]
-        }
-        return result
-    },
-    set: (target, key, value) => {
-        if(typeof key === 'string') {
-            if(key.includes('#/')) {
-                setDefinitionByRef(target, key, value)
-                return true
-            }
-        }
-        target[key] = value
-        return  true
-    }
-}
-
-/**
- * 读写代理内容
- */
-const deepHandler = {
-    get: (target, key) => {
-        let result;
-        if(typeof key === 'string' && key.includes('#/')) {
-            result = queryDefinitionByRef(target, key)
-        }else {
-            result = target[key]
-        }
-        if(['[object Object]', '[object Array]'].includes(Object.prototype.toString.call(result))) {
-            return new Proxy(result, deepHandler)
-        }else {
-            return result
-        }
-    },
-    set: (target, key, value) => {
-        if(typeof key === 'string') {
-            if(key.includes('#/')) {
-                setDefinitionByRef(target, key, value)
-                return true
-            }
-        }
-        target[key] = value
-        return  true
-    }
-}
-
-
-/**
- * 构造函数，创建一个智能读写对象
- * @constructor
- */
-export function shallowRW(data) {
-    return new Proxy(data, handler)
-}
-
-export function RW(data) {
-    if(isNil(data)) {
-        return {}
-    }
-    return new Proxy(data, deepHandler)
-}
-
-export default {
-    RW, shallowRW
-}

package/src/ES/Singleton.js

@@ -1,73 +0,0 @@
-import {isNil} from 'ramda'
-
-class SingletonManage {
-    constructor(option) {
-        // todo 检查option结构
-        this.data = {}
-        this.promiseInstance = {}
-        this.option = option
-    }
-    async get(name) {
-        // 内存有值返回值
-        if(this.data[name]) return this.data[name]
-        // 已发起请求需等待
-        if(this.promiseInstance[name]) {
-            await this.promiseInstance[name]
-            return this.data[name]
-        }
-        if(!this.promiseInstance[name]) {
-            if(!this.option[name]) return null
-            this.promiseInstance[name] = this.option[name]()
-            this.data[name] = await this.promiseInstance[name]
-            this.promiseInstance[name] = null
-            return this.data[name]
-        }
-    }
-    getSync(name) {
-        // 内存有值返回值
-        if(this.data[name]) return this.data[name]
-        else {
-            this.data[name] = this.option[name]()
-            return this.data[name]
-        }
-    }
-    async set(name, func) {
-        // todo 命名冲突校验
-        if(Object.prototype.toString.call(func) === '[object Function]') {
-            this.option[name] = func
-        }else if(Object.prototype.toString.call(func) === '[object AsyncFunction]'){
-            if(!this.promiseInstance[name]) {
-                this.promiseInstance[name] = func()
-                this.data[name] = await this.promiseInstance[name]
-                this.promiseInstance[name] = null
-            }
-        }
-    }
-    async refresh(name) {
-        this.data[name] = null
-        return await this.get(name)
-    }
-}
-
-/**
- * 创建单例仓库
- * @param option 键值是getter函数，可以是async函数
- */
-export function createSM(option) {
-    const instance = new SingletonManage(option)
-    const handler = {
-        get: (target, key) => {
-            if(!isNil(target[key])) {
-                return target[key]
-            }else {
-                return target.getSync(key)
-            }
-        }
-    }
-    // 支持直接取值
-    return new Proxy(instance, handler)
-}
-
-export default {
-    createSM
-}