@quanxiaoxiao/datav 0.2.0 → 0.3.1

package/eslint.config.mjs

@@ -0,0 +1,40 @@
+import js from '@eslint/js';
+import globals from 'globals';
+
+export default [
+  {
+    ignores: [
+      '_resources/*',
+      'static/*',
+      'node_modules/*',
+    ],
+  },
+  js.configs.recommended,
+  {
+    files: [
+      'src/**/*.mjs',
+      '_index.mjs',
+      'scripts/**/*.mjs',
+      'eslint.config.mjs',
+    ],
+    languageOptions: {
+      ecmaVersion: 2022,
+      sourceType: 'module',
+      globals: {
+        ...globals.node,
+      },
+    },
+    rules: {
+      'no-console': 0,
+      'max-len': 0,
+      'no-continue': 0,
+      'no-bitwise': 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,
+    },
+  },
+];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quanxiaoxiao/datav",
-  "version": "0.2.0",
+  "version": "0.3.1",
   "type": "module",
   "scripts": {
     "test": "node --test"
@@ -11,16 +11,9 @@
     "./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"
+    "@eslint/js": "^9.3.0",
+    "eslint": "^9.3.0",
+    "globals": "^15.3.0"
   },
   "publishConfig": {
     "registry": "https://registry.npmjs.org"
@@ -29,6 +22,7 @@
     "node": ">= 20.0.0"
   },
   "dependencies": {
+    "@quanxiaoxiao/utils": "^0.9.0",
     "ajv": "^8.12.0",
     "lodash": "^4.17.21"
   }

package/src/checkout.mjs

@@ -57,7 +57,7 @@ const map = {
   [DATA_TYPE_JSON]: (v) => {
     try {
       return JSON.parse(v);
-    } catch (error) {
+    } catch (error) { // eslint-disable-line
       return null;
     }
   },
@@ -71,7 +71,7 @@ const map = {
         return null;
       }
       return d;
-    } catch (error) {
+    } catch (error) { // eslint-disable-line
       return null;
     }
   },
@@ -82,7 +82,7 @@ const map = {
         return d;
       }
       return [];
-    } catch (error) {
+    } catch (error) { // eslint-disable-line
       return [];
     }
   },

package/src/checkout.test.mjs

@@ -69,6 +69,9 @@ test('checkout with number', () => {
   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('2.5a', 'number'), null);
+  assert.equal(checkout('2.5.', 'number'), null);
+  assert.equal(checkout('2.5.8', 'number'), null);
   assert.equal(checkout(1, 'number'), 1);
   assert(Number.isNaN(checkout(NaN, 'number')));
 });

package/src/index.mjs

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

package/src/select/index.mjs

@@ -1,8 +1,8 @@
 /* eslint no-use-before-define: 0 */
 import _ from 'lodash';
+import { getValueOfPathname } from '@quanxiaoxiao/utils';
 import check from './check.mjs';
 import checkout from '../checkout.mjs';
-import getValueOfPathname from '../getValueOfPathname.mjs';
 
 function walkWithObject(properties) {
   const keys = Object.keys(properties);
@@ -46,9 +46,9 @@ function select(express) {
     return (obj, _root) => {
       const root = _root == null ? obj : _root;
       if (pathname.startsWith('$')) {
-        return walk(getValueOfPathname(root, pathname.slice(1)), root);
+        return walk(getValueOfPathname(pathname.slice(1))(root), root);
       }
-      return walk(getValueOfPathname(obj, pathname), root);
+      return walk(getValueOfPathname(pathname)(obj), root);
     };
   }
   check(express);
@@ -83,7 +83,7 @@ function select(express) {
       const [pathname] = express.properties;
       if (!Array.isArray(arr)) {
         if (pathname.startsWith('$')) {
-          const ret = walk(getValueOfPathname(root, pathname.slice(1)), root);
+          const ret = walk(getValueOfPathname(pathname.slice(1))(root), root);
           if (ret == null) {
             return [];
           }
@@ -95,7 +95,7 @@ function select(express) {
         if (pathname === '' || pathname === '.') {
           return walk(d, root);
         }
-        return walk(getValueOfPathname(d, pathname), root);
+        return walk(getValueOfPathname(pathname)(d), root);
       });
     };
   }

package/src/select/index.test.mjs

@@ -271,6 +271,7 @@ test('select > index, type with object', () => {
       age: {
         type: 'number',
       },
+      ddd: ['obj.name', { type: 'string' }],
       sub: ['obj', {
         type: 'object',
         properties: {
@@ -295,6 +296,7 @@ test('select > index, type with object', () => {
   }), {
     name: 'quan',
     age: 22.5,
+    ddd: 'xxx',
     sub: {
       name: 'xxx',
       age: 33,
@@ -687,6 +689,26 @@ test('select > index, resolve', () => {
       age: 34,
     },
   );
+  assert.deepEqual(
+    select({
+      type: 'object',
+      properties: {
+        name: {
+          type: 'string',
+        },
+        age: {
+          type: 'integer',
+          resolve: () => 99,
+        },
+      },
+    })({
+      name: 'quan',
+    }),
+    {
+      name: 'quan',
+      age: 99,
+    },
+  );
   assert.deepEqual(
     select({
       type: 'object',
@@ -837,3 +859,262 @@ test('select > index, resolve pathList', () => {
     ],
   });
 });
+
+test('select > index, resolve pathList 2', () => {
+  const ret = select(
+    {
+      type: 'object',
+      properties: {
+        count: {
+          type: 'integer',
+        },
+        list: {
+          type: 'array',
+          properties: ['.name', {
+            type: 'string',
+          }],
+        },
+      },
+    },
+  )({
+    count: 20,
+    list: [
+      {
+        name: 'big',
+        age: 11,
+      },
+      {
+        name: 'bar',
+        age: 22,
+      },
+    ],
+  });
+  assert.deepEqual(ret, {
+    count: 20,
+    list: ['big', 'bar'],
+  });
+});
+
+test('select array array array', () => {
+  const array = [[['11', 22], ['33', 44]], [[1], [2]]];
+  const ret = select({
+    type: 'array',
+    properties: ['.', {
+      type: 'array',
+      properties: ['.', {
+        type: 'array',
+        properties: ['.', { type: 'number' }],
+      }],
+    }],
+  })(array);
+  assert.deepEqual(ret, [[[11, 22], [33, 44]], [[1], [2]]]);
+});
+
+test('select object array array array', () => {
+  const obj = {
+    name: 'xxx',
+    arr: [[['11', 22], ['33', 44]], [[1], [2]]],
+  };
+  const ret = select({
+    type: 'object',
+    properties: {
+      name: {
+        type: 'string',
+      },
+      arr: ['arr', {
+        type: 'array',
+        properties: ['.', {
+          type: 'array',
+          properties: ['.', {
+            type: 'array',
+            properties: ['.', { type: 'number' }],
+          }],
+        }],
+      }],
+    },
+  })(obj);
+  assert.deepEqual(ret.arr, [[[11, 22], [33, 44]], [[1], [2]]]);
+});
+
+test('select 222', () => {
+  const obj = {
+    data: {
+      key: 'aaaabbb',
+    },
+  };
+  assert.equal(select(['.data.key', { type: 'string' }])(obj), obj.data.key);
+});
+
+test('select 333', () => {
+  const obj = {
+    data: ['222', '333'],
+  };
+  assert.deepEqual(select(['.data', { type: 'array', properties: ['.', { type: 'string' }] }])(obj), obj.data);
+});
+
+test('select 444', () => {
+  const key = '111222';
+
+  const ret = select({
+    type: 'object',
+    properties: {
+      name: ['.', {
+        type: 'string',
+      }],
+    },
+  })(key);
+  assert.deepEqual(ret, { name: key });
+});
+
+test('select 5555', () => {
+  const data = {
+    deviceId: '101007351946',
+    channelId: '2',
+    sn: '286329',
+    name: null,
+    sumNum: 4,
+    count: 4,
+    lastTime: null,
+    recordList: [
+      {
+        deviceId: '101007351946',
+        startTime: '2024-06-25 10:09:37',
+        endTime: '2024-06-25 13:45:32',
+      },
+      {
+        deviceId: '101007351946',
+        startTime: '2024-06-25 13:47:16',
+        endTime: '2024-06-25 17:01:19',
+      },
+      {
+        deviceId: '101007351946',
+        startTime: '2024-06-25 17:01:19',
+        endTime: '2024-06-25 17:01:21',
+      },
+      {
+        deviceId: '101007351946',
+        startTime: '2024-06-25 17:01:21',
+        endTime: '2024-06-25 18:11:39',
+      },
+    ],
+  };
+  const ret = select(['.recordList', {
+    type: 'array',
+    properties: {
+      dateTimeNameStart: ['.startTime', { type: 'string' }],
+      dateTimeNameEnd: ['.endTime', { type: 'string' }],
+    },
+  }])(data);
+  assert.deepEqual(
+    ret,
+    data.recordList.map((d) => ({
+      dateTimeNameStart: d.startTime,
+      dateTimeNameEnd: d.endTime,
+    })),
+  );
+});
+
+test('select 666', () => {
+  const ret = select({
+    type: 'object',
+    properties: {
+      chl: {
+        type: 'array',
+        properties: ['$channel', { type: 'string' }],
+      },
+    },
+  })({
+    channel: '1',
+  });
+  assert.deepEqual(ret, { chl: ['1'] });
+});
+
+test('select 777', () => {
+  const ret = select({
+    type: 'object',
+    properties: {
+      key: {
+        type: 'string',
+      },
+      params: {
+        type: 'array',
+        properties: {
+          task: ['$taskId', { type: 'number' }],
+          date: ['$dateName', { type: 'string' }],
+        },
+      },
+    },
+  })({
+    key: '123',
+    taskId: '999',
+    dateName: '2024-06-06',
+  });
+  assert.deepEqual(ret, {
+    key: '123',
+    params: [
+      {
+        task: '999',
+        date: '2024-06-06',
+      },
+    ],
+  });
+});
+
+test('select 888', () => {
+  const ret = select({
+    type: 'object',
+    properties: {
+      dir: ['.data.0.dir', { type: 'string' }],
+      name: ['.data.0.name', { type: 'string' }],
+    },
+  })({
+    data: [
+      {
+        dir: 'QzpcVmlkZW9ccXExMjM0XDIwMTctMDYtMTlccmVjb3JkXDE=',
+        name: 'qq1234-170619-000000-002000-01p401000000.264'
+      },
+      {
+        dir: 'QzpcVmlkZW9ccXExMjM0XDIwMTctMDYtMTlccmVjb3JkXDE=',
+        name: 'qq1234-170619-000000-002000-01p401000000.mp4'
+      }
+    ],
+    errorcode: 200
+  });
+  assert.deepEqual(ret, {
+    dir: 'QzpcVmlkZW9ccXExMjM0XDIwMTctMDYtMTlccmVjb3JkXDE=',
+    name: 'qq1234-170619-000000-002000-01p401000000.264'
+  });
+});
+
+test('select object empty properties', () => {
+  const data = {
+    code: 0,
+    data: {
+      'name': 'data111',
+      '/aaa': {
+        name: '123',
+        '/ccc': {
+          name: 'ccc',
+        },
+      },
+      '/sss': {
+        name: '999',
+      },
+    },
+  };
+  const ret = select({
+    type: 'object',
+    properties: {
+      route: ['.data', {
+        type: 'object',
+        properties: {},
+      }],
+    },
+  })(data);
+  assert.deepEqual(
+    {
+      route: data.data,
+    },
+    ret,
+  );
+});

package/.babelrc

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

package/.eslintrc

@@ -1,29 +0,0 @@
-{
-  "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/src/getValueOfPathname.mjs

@@ -1,42 +0,0 @@
-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 (!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

@@ -1,29 +0,0 @@
-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);
-});