@quanxiaoxiao/datav 0.1.0

package/.babelrc

@@ -0,0 +1,7 @@
+{
+  "plugins": [
+    "@babel/plugin-proposal-optional-chaining",
+    "@babel/plugin-proposal-nullish-coalescing-operator",
+    "@babel/plugin-syntax-import-attributes"
+  ]
+}

package/.editorconfig

@@ -0,0 +1,13 @@
+root = true
+
+[*]
+end_of_line = lf
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true
+indent_style = space
+indent_size = 2
+max_line_length = 100
+
+[*.md]
+trim_trailing_whitespace = false

package/.eslintrc

@@ -0,0 +1,29 @@
+{
+  "parser": "@babel/eslint-parser",
+  "extends": "eslint-config-airbnb",
+  "env": {
+    "node": true
+  },
+  "rules": {
+    "no-console": 0,
+    "max-len": 0,
+    "no-continue": 0,
+    "no-bitwise": 0,
+    "import/no-extraneous-dependencies": [
+      "error",
+      {
+        "devDependencies": true,
+        "optionalDependencies": false,
+        "peerDependencies": false
+      }
+    ],
+    "no-param-reassign": 0,
+    "no-mixed-operators": 0,
+    "no-underscore-dangle": 0,
+    "import/prefer-default-export": 0,
+    "class-methods-use-this": 0,
+    "no-plusplus": 0,
+    "global-require": 0
+  },
+  "globals": {}
+}

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@quanxiaoxiao/datav",
+  "version": "0.1.0",
+  "type": "module",
+  "scripts": {
+    "test": "node --test"
+  },
+  "main": "./src/index.mjs",
+  "exports": {
+    ".": "./src/index.mjs",
+    "./package.json": "./package.json"
+  },
+  "devDependencies": {
+    "@babel/eslint-parser": "^7.23.10",
+    "@babel/plugin-proposal-nullish-coalescing-operator": "^7.18.6",
+    "@babel/plugin-proposal-optional-chaining": "^7.21.0",
+    "@babel/plugin-syntax-import-attributes": "^7.23.3",
+    "eslint": "^8.56.0",
+    "eslint-config-airbnb": "^19.0.4",
+    "eslint-plugin-import": "^2.29.1",
+    "eslint-plugin-jsx-a11y": "^6.8.0",
+    "eslint-plugin-react": "^7.33.2",
+    "eslint-plugin-react-hooks": "^4.6.0"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org"
+  },
+  "engines": {
+    "node": ">= 20.0.0"
+  },
+  "dependencies": {
+    "ajv": "^8.12.0",
+    "lodash": "^4.17.21"
+  }
+}

package/src/checkout.mjs

@@ -0,0 +1,134 @@
+import _ from 'lodash';
+
+const DATA_TYPE_NUMBER = 'number';
+const DATA_TYPE_STRING = 'string';
+const DATA_TYPE_BOOLEAN = 'boolean';
+const DATA_TYPE_JSON = 'json';
+const DATA_TYPE_ARRAY = 'array';
+const DATA_TYPE_OBJECT = 'object';
+const DATA_TYPE_INTEGER = 'integer';
+
+const map = {
+  [DATA_TYPE_STRING]: (v) => {
+    if (typeof v !== 'string') {
+      return v.toString ? `${v.toString()}` : JSON.stringify(v);
+    }
+    return v;
+  },
+  [DATA_TYPE_INTEGER]: (v) => {
+    if (Number.isNaN(v)) {
+      return v;
+    }
+    if (v === '') {
+      return null;
+    }
+    const type = typeof v;
+    if (type !== 'number' && type !== 'string') {
+      return null;
+    }
+    const number = Number(v);
+    if (Number.isNaN(number)) {
+      return null;
+    }
+    if (`${number}` !== `${v}`) {
+      return null;
+    }
+    return parseInt(number, 10);
+  },
+  [DATA_TYPE_NUMBER]: (v) => {
+    if (v === '') {
+      return null;
+    }
+    const number = Number(v);
+    if (Number.isNaN(number)) {
+      return null;
+    }
+    if (`${number}` !== `${v}`) {
+      return null;
+    }
+    return number;
+  },
+  [DATA_TYPE_BOOLEAN]: (v) => {
+    if (v !== 'false' && v !== 'true') {
+      return null;
+    }
+    return v === 'true';
+  },
+  [DATA_TYPE_JSON]: (v) => {
+    try {
+      return JSON.parse(v);
+    } catch (error) {
+      return null;
+    }
+  },
+  [DATA_TYPE_OBJECT]: (v) => {
+    try {
+      const d = JSON.parse(v);
+      if (Array.isArray(d)) {
+        return null;
+      }
+      if (typeof d !== 'object') {
+        return null;
+      }
+      return d;
+    } catch (error) {
+      return null;
+    }
+  },
+  [DATA_TYPE_ARRAY]: (v) => {
+    try {
+      const d = JSON.parse(v);
+      if (Array.isArray(d)) {
+        return d;
+      }
+      return [];
+    } catch (error) {
+      return [];
+    }
+  },
+};
+
+const typeNameMap = {
+  [DATA_TYPE_NUMBER]: 'number',
+  [DATA_TYPE_STRING]: 'string',
+  [DATA_TYPE_INTEGER]: 'integer',
+  [DATA_TYPE_BOOLEAN]: 'boolean',
+  [DATA_TYPE_JSON]: 'object',
+  [DATA_TYPE_ARRAY]: 'object',
+  [DATA_TYPE_OBJECT]: 'object',
+};
+
+export default (value, type) => {
+  if (type == null) {
+    throw new Error('data type is empty');
+  }
+  if (!Object.hasOwnProperty.call(map, type)) {
+    throw new Error(`\`${type}\` invalid data type`);
+  }
+  if (value == null) {
+    if (type === 'array') {
+      return [];
+    }
+    return null;
+  }
+  const valueType = typeof value;
+  if (valueType !== 'string') {
+    if (type === DATA_TYPE_INTEGER) {
+      return map[DATA_TYPE_INTEGER](value);
+    }
+    if (type === DATA_TYPE_STRING) {
+      return map[DATA_TYPE_STRING](value);
+    }
+    if (valueType === typeNameMap[type]) {
+      if (type === DATA_TYPE_ARRAY) {
+        return Array.isArray(value) ? value : [];
+      }
+      if (type === DATA_TYPE_OBJECT) {
+        return _.isPlainObject(value) ? value : null;
+      }
+      return value;
+    }
+    return type === DATA_TYPE_ARRAY ? [] : null;
+  }
+  return map[type](value);
+};

package/src/checkout.test.mjs

@@ -0,0 +1,140 @@
+import test from 'node:test';
+import assert from 'node:assert';
+import checkout from './checkout.mjs';
+
+test('checkout invalid data type', () => {
+  assert.throws(() => {
+    checkout('aaa', 'bbb');
+  });
+  assert.throws(() => {
+    checkout('aaa');
+  });
+});
+
+test('checkout with data value null', () => {
+  assert.deepEqual(checkout(null, 'array'), []);
+  assert.equal(checkout(null, 'object'), null);
+  assert.equal(checkout(null, 'string'), null);
+  assert.equal(checkout(null, 'number'), null);
+  assert.equal(checkout(null, 'integer'), null);
+  assert.equal(checkout(null, 'boolean'), null);
+  assert.equal(checkout(null, 'json'), null);
+});
+
+test('checkout with string', () => {
+  assert.equal(checkout(1, 'string'), '1');
+  assert.equal(checkout(null, 'string'), null);
+  assert.equal(checkout(true, 'string'), 'true');
+  assert.equal(checkout(false, 'string'), 'false');
+  assert.equal(checkout(' 1', 'string'), ' 1');
+  assert.equal(checkout([1, 2, 3], 'string'), '1,2,3');
+  assert.equal(checkout({ name: 'cqq' }, 'string'), '[object Object]');
+  assert.equal(checkout({
+    name: 'quan',
+    toString: () => 'cqq',
+  }, 'string'), 'cqq');
+});
+
+test('checkout with integer', () => {
+  assert.equal(checkout(null, 'integer'), null);
+  assert.equal(checkout('', 'integer'), null);
+  assert.equal(checkout(true, 'integer'), null);
+  assert.equal(checkout(false, 'integer'), null);
+  assert.equal(checkout([], 'integer'), null);
+  assert.equal(checkout({}, 'integer'), null);
+  assert.equal(checkout('aaa', 'integer'), null);
+  assert.equal(checkout('1', 'integer'), 1);
+  assert.equal(checkout('01', 'integer'), null);
+  assert.equal(checkout(' 1', 'integer'), null);
+  assert.equal(checkout('1.1', 'integer'), 1);
+  assert.equal(checkout('-3.1', 'integer'), -3);
+  assert.equal(checkout(3.1, 'integer'), 3);
+  assert.equal(checkout(1, 'integer'), 1);
+  assert(Number.isNaN(checkout(NaN, 'integer')));
+});
+
+test('checkout with number', () => {
+  assert.equal(checkout('1', 'number'), 1);
+  assert.equal(checkout('01', 'number'), null);
+  assert.equal(checkout(true, 'number'), null);
+  assert.equal(checkout(false, 'number'), null);
+  assert.equal(checkout([], 'number'), null);
+  assert.equal(checkout({}, 'number'), null);
+  assert.equal(checkout('', 'number'), null);
+  assert.equal(checkout('a', 'number'), null);
+  assert.equal(checkout('1a', 'number'), null);
+  assert.equal(checkout('0', 'number'), 0);
+  assert.equal(checkout('-0', 'number'), null);
+  assert.equal(checkout('-1', 'number'), -1);
+  assert.equal(checkout('-1.5', 'number'), -1.5);
+  assert.equal(checkout('-2.5', 'number'), -2.5);
+  assert.equal(checkout('2.5', 'number'), 2.5);
+  assert.equal(checkout(1, 'number'), 1);
+  assert(Number.isNaN(checkout(NaN, 'number')));
+});
+
+test('checkout with boolean', () => {
+  assert.equal(checkout('', 'boolean'), null);
+  assert.equal(checkout('false', 'boolean'), false);
+  assert.equal(checkout(' false', 'boolean'), null);
+  assert.equal(checkout('false ', 'boolean'), null);
+  assert.equal(checkout('true', 'boolean'), true);
+  assert.equal(checkout(' true', 'boolean'), null);
+  assert.equal(checkout('true ', 'boolean'), null);
+  assert.equal(checkout(true, 'boolean'), true);
+  assert.equal(checkout(false, 'boolean'), false);
+  assert.equal(checkout(1, 'boolean'), null);
+  assert.equal(checkout({}, 'boolean'), null);
+  assert.equal(checkout([], 'boolean'), null);
+  assert.equal(checkout('aaa', 'boolean'), null);
+});
+
+test('checkout with json', () => {
+  assert.equal(checkout('1', 'json'), 1);
+  assert.equal(checkout(' 1', 'json'), 1);
+  assert.equal(checkout('"1"', 'json'), '1');
+  assert.equal(checkout('\'1\'', 'json'), null);
+  assert.equal(checkout('null', 'json'), null);
+  assert.equal(checkout('aa', 'json'), null);
+  assert.deepEqual(checkout('{}', 'json'), {});
+  assert.deepEqual(checkout('{fail}', 'json'), null);
+  assert.deepEqual(checkout('{"name":"cqq"}', 'json'), { name: 'cqq' });
+  assert.deepEqual(checkout('[]', 'json'), []);
+  assert.deepEqual(checkout([], 'json'), []);
+  assert.deepEqual(checkout({}, 'json'), {});
+  assert.deepEqual(checkout(2, 'json'), null);
+});
+
+test('checkout with array', () => {
+  assert.deepEqual(checkout(null, 'array'), []);
+  assert.deepEqual(checkout('[]', 'array'), []);
+  assert.deepEqual(checkout('[xxx]', 'array'), []);
+  assert.deepEqual(checkout([], 'array'), []);
+  assert.deepEqual(checkout([1, 2, 3], 'array'), [1, 2, 3]);
+  assert.deepEqual(checkout(1, 'array'), []);
+  assert.deepEqual(checkout({}, 'array'), []);
+  assert.deepEqual(checkout('1', 'array'), []);
+  assert.deepEqual(checkout('{}', 'array'), []);
+  assert.deepEqual(checkout(['12345'], 'array'), ['12345']);
+  assert.deepEqual(checkout(true, 'array'), []);
+  assert.deepEqual(checkout(false, 'array'), []);
+  assert.deepEqual(checkout([{ name: 'cqq' }], 'array'), [{ name: 'cqq' }]);
+  assert.deepEqual(checkout(JSON.stringify([{ name: 'cqq' }]), 'array'), [{ name: 'cqq' }]);
+});
+
+test('checkout with object', () => {
+  assert.equal(checkout(null, 'object'), null);
+  assert.equal(checkout(1, 'object'), null);
+  assert.equal(checkout('aa', 'object'), null);
+  assert.equal(checkout('1', 'object'), null);
+  assert.equal(checkout(JSON.stringify('aa'), 'object'), null);
+  assert.equal(checkout(true, 'object'), null);
+  assert.equal(checkout('true', 'object'), null);
+  assert.equal(checkout('false', 'object'), null);
+  assert.equal(checkout(false, 'object'), null);
+  assert.equal(checkout([], 'object'), null);
+  assert.equal(checkout(JSON.stringify([]), 'object'), null);
+  assert.deepEqual(checkout({ name: 'cqq' }, 'object'), { name: 'cqq' });
+  assert.deepEqual(checkout(JSON.stringify({ name: 'cqq' }), 'object'), { name: 'cqq' });
+  assert.deepEqual(checkout('{fail}', 'object'), null);
+});

package/src/getValueOfPathname.mjs

@@ -0,0 +1,44 @@
+import _ from 'lodash';
+
+const walk = (obj, nameList) => {
+  const [dataKey, ...other] = nameList;
+  if (Array.isArray(obj)) {
+    const n = parseInt(dataKey, 10);
+    if (Number.isNaN(n) || `${n}` !== dataKey) {
+      return null;
+    }
+    const len = obj.length;
+    if (n > len) {
+      return null;
+    }
+    if (other.length === 0) {
+      return obj[n];
+    }
+    return walk(obj[n], other);
+  }
+  if (!Object.hasOwnProperty.call(obj, dataKey)) {
+    return null;
+  }
+  const value = obj[dataKey];
+  if (other.length === 0) {
+    return value;
+  }
+  return walk(value, other);
+};
+
+export default (obj, pathname) => {
+  if (typeof pathname !== 'string' || (/\.$/.test(pathname) && pathname !== '.')) {
+    throw new Error('pathname invalid');
+  }
+  if (!Array.isArray(obj) && !_.isPlainObject(obj)) {
+    return null;
+  }
+  let str = pathname;
+  if (pathname.startsWith('.')) {
+    str = pathname.slice(1);
+  }
+  if (str === '') {
+    return obj;
+  }
+  return walk(obj, str.split(/(?<!\\)\./).map((d) => d.replace(/\\\./g, '.')));
+};

package/src/getValueOfPathname.test.mjs

@@ -0,0 +1,29 @@
+import assert from 'node:assert';
+import test from 'node:test';
+import getValueOfPathname from './getValueOfPathname.mjs';
+
+test('getValueOfPathname', () => {
+  assert.throws(() => {
+    getValueOfPathname({}, 11);
+  });
+  assert.throws(() => {
+    getValueOfPathname({}, 'name.');
+  });
+  assert.deepEqual(getValueOfPathname({}, '.'), {});
+  assert.equal(getValueOfPathname([], 'name'), null);
+  assert.equal(getValueOfPathname(null, 'xxx'), null);
+  assert.equal(getValueOfPathname({ name: 'quan' }, 'quan'), null);
+  assert.equal(getValueOfPathname({ name: 'quan' }, 'name'), 'quan');
+  assert.equal(getValueOfPathname({ name: 'quan' }, '.name'), 'quan');
+  assert.equal(getValueOfPathname({ '.name': 'quan', name: 'cqq' }, '\\.name'), 'quan');
+  assert.deepEqual(getValueOfPathname({ name: 'quan' }, ''), { name: 'quan' });
+  assert.deepEqual(getValueOfPathname({ name: 'quan', obj: { foo: 'bar' } }, 'obj'), { foo: 'bar' });
+  assert.equal(getValueOfPathname({ name: 'quan', obj: { name: 'bar' } }, 'obj.name'), 'bar');
+  assert.equal(getValueOfPathname({ 'obj.name': 'xxx', name: 'quan', obj: { name: 'bar' } }, 'obj\\.name'), 'xxx');
+});
+
+test('getValueOfPathname of array', () => {
+  assert.equal(getValueOfPathname([{ name: 'aa' }, { name: 'bb' }], '0.name'), 'aa');
+  assert.equal(getValueOfPathname([{ name: 'aa' }, { name: 'bb' }], '5.name'), null);
+  assert.equal(getValueOfPathname([{ name: 'aa' }, { name: 'bb' }], '5'), null);
+});

package/src/index.mjs

@@ -0,0 +1,9 @@
+import checkout from './checkout.mjs';
+import getValueOfPathname from './getValueOfPathname.mjs';
+import select from './select/index.mjs';
+
+export {
+  select,
+  checkout,
+  getValueOfPathname,
+};

package/src/select/check.mjs

@@ -0,0 +1,63 @@
+import Ajv from 'ajv';
+
+const ajv = new Ajv();
+
+const validate = ajv.compile({
+  type: 'object',
+  anyOf: [
+    {
+      properties: {
+        type: {
+          enum: ['object'],
+        },
+        properties: {
+          type: 'object',
+        },
+      },
+      required: ['type', 'properties'],
+    },
+    {
+      properties: {
+        type: {
+          enum: ['array'],
+        },
+        properties: {
+          anyOf: [
+            {
+              type: 'object',
+            },
+            {
+              type: 'array',
+              items: [
+                {
+                  type: 'string',
+                },
+                {
+                  type: 'object',
+                },
+              ],
+              additionalItems: false,
+              minItems: 2,
+              maxItems: 2,
+            },
+          ],
+        },
+      },
+      required: ['type', 'properties'],
+    },
+    {
+      properties: {
+        type: {
+          enum: ['string', 'number', 'boolean', 'integer'],
+        },
+      },
+      required: ['type'],
+    },
+  ],
+});
+
+export default (express) => {
+  if (!validate(express)) {
+    throw new Error(`\`${JSON.stringify(express)}\` ${JSON.stringify(validate.errors)}`);
+  }
+};

package/src/select/check.test.mjs

@@ -0,0 +1,75 @@
+import assert from 'node:assert';
+import test from 'node:test';
+import check from './check.mjs';
+
+test('select > check', () => {
+  assert.throws(() => {
+    check([]);
+  });
+  assert.throws(() => {
+    check('number');
+  });
+  assert.throws(() => {
+    check('integer');
+  });
+  assert.throws(() => {
+    check({});
+  });
+  assert.throws(() => {
+    check({
+      type: 'object',
+      properties: [],
+    });
+  });
+  assert.throws(() => {
+    check({
+      type: 'xxx',
+    });
+  });
+  assert.throws(() => {
+    check({
+      type: 'json',
+    });
+  });
+  assert.throws(() => {
+    check({
+      type: 'array',
+      properties: [],
+    });
+  });
+  assert.throws(() => {
+    check({
+      type: 'array',
+      properties: ['dataKey', []],
+    });
+  });
+  check({
+    type: 'string',
+  });
+  check({
+    type: 'string',
+    properties: ['dataKey'],
+  });
+  check({
+    type: 'string',
+    properties: ['dataKey', []],
+  });
+  check({
+    type: 'string',
+    properties: ['dataKey', {}],
+  });
+  check({
+    type: 'object',
+    properties: {
+    },
+  });
+  check({
+    type: 'array',
+    properties: {
+    },
+  });
+  check({
+    type: 'array',
+    properties: ['dataKey', {}],
+  });
+});

package/src/select/index.mjs

@@ -0,0 +1,108 @@
+/* eslint no-use-before-define: 0 */
+import _ from 'lodash';
+import check from './check.mjs';
+import checkout from '../checkout.mjs';
+import getValueOfPathname from '../getValueOfPathname.mjs';
+
+function walkWithObject(properties) {
+  const keys = Object.keys(properties);
+  const list = [];
+  for (let i = 0; i < keys.length; i++) {
+    const dataKey = keys[i];
+    const express = properties[dataKey];
+    const handler = {
+      dataKey,
+      express,
+      fn: select(express),
+    };
+    list.push(handler);
+  }
+  return (d, _root) => {
+    const root = _root == null ? d : _root;
+    return list.reduce((acc, cur) => {
+      if (Array.isArray(cur.express)) {
+        return {
+          ...acc,
+          [cur.dataKey]: cur.fn(d, root),
+        };
+      }
+      return {
+        ...acc,
+        [cur.dataKey]: cur.fn(d == null ? d : d[cur.dataKey], root),
+      };
+    }, {});
+  };
+}
+
+function select(express) {
+  if (Array.isArray(express)) {
+    const [pathname] = express;
+    if (typeof pathname !== 'string'
+      || !_.isPlainObject(express[1])
+    ) {
+      throw new Error(`\`${JSON.stringify(express)}\` express invalid`);
+    }
+    const walk = select(express[1]);
+    return (obj, _root) => {
+      const root = _root == null ? obj : _root;
+      if (pathname.startsWith('$')) {
+        return walk(getValueOfPathname(root, pathname.slice(1)), root);
+      }
+      return walk(getValueOfPathname(obj, pathname), root);
+    };
+  }
+  check(express);
+  if (['string', 'number', 'boolean', 'integer'].includes(express.type)) {
+    return (v, _root) => {
+      const root = _root == null ? v : _root;
+      let value = v;
+      if (express.resolve) {
+        value = express.resolve(value, root);
+      }
+      return checkout(value, express.type);
+    };
+  }
+  if (express.resolve) {
+    console.warn('data type `array` or `object` unspport resolve');
+  }
+  if (express.type === 'object') {
+    return walkWithObject(express.properties);
+  }
+  if (Array.isArray(express.properties)) {
+    const walk = select(express.properties[1]);
+    return (arr, _root) => {
+      const root = _root == null ? arr : _root;
+      const [pathname] = express.properties;
+      if (!Array.isArray(arr)) {
+        if (pathname.startsWith('$')) {
+          const ret = walk(getValueOfPathname(root, pathname.slice(1)), root);
+          if (ret == null) {
+            return [];
+          }
+          return [ret];
+        }
+        return [];
+      }
+      return arr.map((d) => {
+        if (pathname === '' || pathname === '.') {
+          return walk(d, root);
+        }
+        return walk(getValueOfPathname(d, pathname), root);
+      });
+    };
+  }
+  const walk = walkWithObject(express.properties);
+  return (arr, _root) => {
+    const root = _root == null ? arr : _root;
+    if (!Array.isArray(arr)) {
+      if (_.isEmpty(express.properties)) {
+        return [];
+      }
+      const ret = walk(arr, root);
+      return [ret];
+    }
+    return arr.map((d) => walk(d, root));
+  };
+}
+
+export default select;