@quanxiaoxiao/datav 0.4.0 → 0.5.1

package/package.json

@@ -1,20 +1,60 @@
 {
   "name": "@quanxiaoxiao/datav",
-  "version": "0.4.0",
+  "version": "0.5.1",
+  "description": "Data transformation utility with type conversion, path access, and schema-driven data transformation",
   "type": "module",
+  "keywords": [
+    "data",
+    "transform",
+    "schema",
+    "typescript",
+    "type-conversion",
+    "util"
+  ],
+  "author": "quanxiaoxiao",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/quanxiaoxiao/datav.git"
+  },
+  "bugs": {
+    "url": "https://github.com/quanxiaoxiao/datav/issues"
+  },
+  "homepage": "https://github.com/quanxiaoxiao/datav#readme",
+  "files": [
+    "src",
+    "dist",
+    "package.json",
+    "README.md"
+  ],
+  "sideEffects": false,
   "scripts": {
-    "test": "node --test"
+    "test": "TSX_TSCONFIG=tsconfig.test.json node --import tsx --test 'src/**/*.test.ts'",
+    "build": "tsc && rm -rf dist/*.test.* dist/**/*.test.*",
+    "check": "tsc --noEmit",
+    "lint": "eslint .",
+    "format": "prettier --write ."
   },
-  "main": "./src/index.mjs",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "module": "./dist/index.js",
   "exports": {
-    ".": "./src/index.mjs",
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
     "./package.json": "./package.json"
   },
   "devDependencies": {
     "@eslint/js": "^9.22.0",
+    "@types/node": "^25.0.8",
     "eslint": "^9.22.0",
     "eslint-plugin-simple-import-sort": "^12.1.1",
-    "globals": "^15.15.0"
+    "globals": "^17.0.0",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.53.0"
   },
   "publishConfig": {
     "registry": "https://registry.npmjs.org"
@@ -23,8 +63,6 @@
     "node": ">= 20.0.0"
   },
   "dependencies": {
-    "@quanxiaoxiao/utils": "^0.16.0",
-    "ajv": "^8.12.0",
-    "lodash": "^4.17.21"
+    "ajv": "^8.12.0"
   }
 }

package/src/createArrayAccessor.test.ts

@@ -0,0 +1,181 @@
+import * as assert from 'node:assert';
+import { describe, it } from 'node:test';
+
+import { createArrayAccessor } from './createArrayAccessor.js';
+
+describe('createArrayAccessor', () => {
+  const testArray = ['a', 'b', 'c', 'd', 'e'];
+
+  describe('数字索引访问', () => {
+    it('应该返回正确的数组元素 - 正数索引', () => {
+      const accessor = createArrayAccessor(0);
+      assert.strictEqual(accessor(testArray), 'a');
+
+      const accessor2 = createArrayAccessor(2);
+      assert.strictEqual(accessor2(testArray), 'c');
+
+      const accessor4 = createArrayAccessor(4);
+      assert.strictEqual(accessor4(testArray), 'e');
+    });
+
+    it('应该支持负数索引', () => {
+      const accessor = createArrayAccessor(-1);
+      assert.strictEqual(accessor(testArray), 'e');
+
+      const accessor2 = createArrayAccessor(-2);
+      assert.strictEqual(accessor2(testArray), 'd');
+
+      const accessor5 = createArrayAccessor(-5);
+      assert.strictEqual(accessor5(testArray), 'a');
+    });
+
+    it('应该处理索引越界的情况 - 正数', () => {
+      const accessor = createArrayAccessor(10);
+      assert.strictEqual(accessor(testArray), null);
+
+      const accessor2 = createArrayAccessor(5);
+      assert.strictEqual(accessor2(testArray), null);
+    });
+
+    it('应该处理索引越界的情况 - 负数', () => {
+      const accessor = createArrayAccessor(-10);
+      assert.strictEqual(accessor(testArray), null);
+
+      const accessor2 = createArrayAccessor(-6);
+      assert.strictEqual(accessor2(testArray), null);
+    });
+
+    it('应该拒绝浮点数索引', () => {
+      const accessor = createArrayAccessor(1.5);
+      assert.strictEqual(accessor(testArray), null);
+
+      const accessor2 = createArrayAccessor(-2.3);
+      assert.strictEqual(accessor2(testArray), null);
+    });
+  });
+
+  describe('字符串索引访问', () => {
+    it('应该处理 "length" 特殊属性', () => {
+      const accessor = createArrayAccessor('length');
+      assert.strictEqual(accessor(testArray), 5);
+      assert.strictEqual(accessor([]), 0);
+      assert.strictEqual(accessor([1, 2, 3]), 3);
+    });
+
+    it('应该将有效的数字字符串转换为索引', () => {
+      const accessor = createArrayAccessor('0');
+      assert.strictEqual(accessor(testArray), 'a');
+
+      const accessor2 = createArrayAccessor('3');
+      assert.strictEqual(accessor2(testArray), 'd');
+    });
+
+    it('应该支持负数字符串索引', () => {
+      const accessor = createArrayAccessor('-1');
+      assert.strictEqual(accessor(testArray), 'e');
+
+      const accessor2 = createArrayAccessor('-3');
+      assert.strictEqual(accessor2(testArray), 'c');
+    });
+
+    it('应该拒绝无效的字符串索引', () => {
+      const accessor = createArrayAccessor('abc');
+      assert.strictEqual(accessor(testArray), null);
+
+      const accessor2 = createArrayAccessor('1.5');
+      assert.strictEqual(accessor2(testArray), null);
+
+      const accessor3 = createArrayAccessor('01'); // 前导零
+      assert.strictEqual(accessor3(testArray), null);
+
+      const accessor4 = createArrayAccessor('2a');
+      assert.strictEqual(accessor4(testArray), null);
+    });
+  });
+
+  describe('边界情况', () => {
+    it('应该处理空数组', () => {
+      const accessor = createArrayAccessor(0);
+      assert.strictEqual(accessor([]), null);
+
+      const accessor2 = createArrayAccessor(-1);
+      assert.strictEqual(accessor2([]), null);
+    });
+
+    it('应该处理单元素数组', () => {
+      const singleArray = ['only'];
+
+      const accessor0 = createArrayAccessor(0);
+      assert.strictEqual(accessor0(singleArray), 'only');
+
+      const accessor1 = createArrayAccessor(-1);
+      assert.strictEqual(accessor1(singleArray), 'only');
+
+      const accessor2 = createArrayAccessor(1);
+      assert.strictEqual(accessor2(singleArray), null);
+    });
+
+    it('应该拒绝无效的索引类型', () => {
+      const accessor = createArrayAccessor(null as unknown);
+      assert.strictEqual(accessor(testArray), null);
+
+      const accessor2 = createArrayAccessor(undefined as unknown);
+      assert.strictEqual(accessor2(testArray), null);
+
+      const accessor3 = createArrayAccessor({} as unknown);
+      assert.strictEqual(accessor3(testArray), null);
+
+      const accessor4 = createArrayAccessor([] as unknown);
+      assert.strictEqual(accessor4(testArray), null);
+    });
+
+    it('应该处理包含各种类型元素的数组', () => {
+      const mixedArray = [null, undefined, 0, '', false, { key: 'value' }];
+
+      const accessor0 = createArrayAccessor(0);
+      assert.strictEqual(accessor0(mixedArray), null);
+
+      const accessor1 = createArrayAccessor(1);
+      assert.strictEqual(accessor1(mixedArray), undefined);
+
+      const accessor5 = createArrayAccessor(5);
+      assert.deepStrictEqual(accessor5(mixedArray), { key: 'value' });
+    });
+  });
+
+  describe('函数复用性', () => {
+    it('创建的访问器应该可以在多个数组上复用', () => {
+      const accessor = createArrayAccessor(1);
+
+      assert.strictEqual(accessor(['a', 'b', 'c']), 'b');
+      assert.strictEqual(accessor([10, 20, 30]), 20);
+      assert.strictEqual(accessor(['x']), null);
+    });
+
+    it('应该是纯函数,不改变原数组', () => {
+      const originalArray = [1, 2, 3];
+      const accessor = createArrayAccessor(0);
+
+      accessor(originalArray);
+      assert.deepStrictEqual(originalArray, [1, 2, 3]);
+    });
+  });
+
+  describe('特殊数字情况', () => {
+    it('应该正确处理 0 索引', () => {
+      const accessor = createArrayAccessor(0);
+      assert.strictEqual(accessor(testArray), 'a');
+      assert.strictEqual(accessor(['only']), 'only');
+    });
+
+    it('应该正确处理 -0', () => {
+      const accessor = createArrayAccessor(-0);
+      assert.strictEqual(accessor(testArray), 'a');
+    });
+
+    it('应该处理字符串 "0"', () => {
+      const accessor = createArrayAccessor('0');
+      assert.strictEqual(accessor(testArray), 'a');
+    });
+  });
+});

package/src/createArrayAccessor.ts

@@ -0,0 +1,48 @@
+const getArrayElementAt = (index: number, array: unknown[]): unknown => {
+  const length = array.length;
+
+  if (length === 0) {
+    return null;
+  }
+
+  if (index < 0) {
+    const actualIndex = length + index;
+    if (actualIndex < 0) {
+      return null;
+    }
+    return array[actualIndex];
+  }
+
+  if (index >= length) {
+    return null;
+  }
+
+  return array[index];
+};
+
+export function createArrayAccessor(index: string | number): (array: unknown[]) => unknown {
+  const indexType = typeof index;
+
+  if (indexType !== 'string' && indexType !== 'number') {
+    return () => null;
+  }
+
+  if (indexType === 'string') {
+    if (index === 'length') {
+      return (array: unknown[]) => array.length;
+    }
+
+    const numericIndex = parseInt(index as string, 10);
+    if (Number.isNaN(numericIndex) || numericIndex.toString() !== index) {
+      return () => null;
+    }
+
+    return (array: unknown[]) => getArrayElementAt(numericIndex, array);
+  }
+
+  if (!Number.isInteger(index as number)) {
+    return () => null;
+  }
+
+  return (array: unknown[]) => getArrayElementAt(index as number, array);
+}

package/src/createDataAccessor.test.ts

@@ -0,0 +1,220 @@
+import * as assert from 'node:assert';
+import { describe, it } from 'node:test';
+
+import { createDataAccessor } from './createDataAccessor.js';
+import { createArrayAccessor } from './createArrayAccessor.js';
+import { createPathAccessor } from './createPathAccessor.js';
+import { parseDotPath } from './parseDotPath.js';
+
+describe('createDataAccessor', () => {
+  describe('当 pathname 为 null 或 undefined 时', () => {
+    it('应该返回一个始终返回 null 的函数', () => {
+      const accessor = createDataAccessor(null);
+      assert.strictEqual(accessor({ foo: 'bar' }), null);
+      assert.strictEqual(accessor([1, 2, 3]), null);
+      assert.strictEqual(accessor('test'), null);
+    });
+
+    it('应该处理 undefined', () => {
+      const accessor = createDataAccessor(undefined as unknown as string | number | null);
+      assert.strictEqual(accessor({ foo: 'bar' }), null);
+    });
+  });
+
+  describe('当 pathname 为数字时', () => {
+    it('应该为数组创建索引访问器', () => {
+      const accessor = createDataAccessor(2);
+      const testArray = ['a', 'b', 'c'];
+      assert.strictEqual(accessor(testArray), 'c');
+    });
+
+    it('当数据不是数组时应该返回 null', () => {
+      const accessor = createDataAccessor(0);
+      assert.strictEqual(accessor({ foo: 'bar' }), null);
+      assert.strictEqual(accessor('string'), null);
+      assert.strictEqual(accessor(123), null);
+    });
+
+    it('应该处理负数索引', () => {
+      const accessor = createDataAccessor(-1);
+      const testArray = [1, 2, 3];
+      assert.strictEqual(accessor(testArray), 3);
+    });
+  });
+
+  describe('当 pathname 为字符串时', () => {
+    it('应该解析点路径并创建路径访问器', () => {
+      const accessor = createDataAccessor('user.name');
+      const result = accessor({ user: { name: 'John' } });
+      assert.strictEqual(result, 'John');
+    });
+
+    it('应该处理简单的属性路径', () => {
+      const accessor = createDataAccessor('name');
+      const result = accessor({ name: 'Alice' });
+      assert.strictEqual(result, 'Alice');
+    });
+
+    it('应该处理深层嵌套路径', () => {
+      const accessor = createDataAccessor('a.b.c.d');
+      const result = accessor({ a: { b: { c: { d: 'deep value' } } } });
+      assert.strictEqual(result, 'deep value');
+    });
+
+    it('应该返回原数据', () => {
+      const accessor = createDataAccessor('');
+      const input = { name: 'John' };
+      assert.strictEqual(accessor(input), input);
+    });
+
+    it('应该处理数组索引', () => {
+      const accessor = createDataAccessor('0');
+      const result = accessor({ 0: 'first', 1: 'second' });
+      assert.strictEqual(result, 'first');
+    });
+  });
+
+  describe('当 pathname 为其他类型时', () => {
+    it('应该返回一个始终返回 null 的函数 (boolean)', () => {
+      const accessor = createDataAccessor(true as unknown as string | number | null);
+      assert.strictEqual(accessor({ foo: 'bar' }), null);
+    });
+
+    it('应该返回一个始终返回 null 的函数 (object)', () => {
+      const accessor = createDataAccessor({} as unknown as string | number | null);
+      assert.strictEqual(accessor({ foo: 'bar' }), null);
+    });
+
+    it('应该返回一个始终返回 null 的函数 (array)', () => {
+      const accessor = createDataAccessor([] as unknown as string | number | null);
+      assert.strictEqual(accessor({ foo: 'bar' }), null);
+    });
+  });
+
+  describe('访问器函数的复用', () => {
+    it('同一个访问器应该可以多次调用', () => {
+      const accessor = createDataAccessor('value');
+
+      accessor({ value: 1 });
+      accessor({ value: 2 });
+      const result = accessor({ value: 3 });
+
+      assert.strictEqual(result, 3);
+    });
+
+    it('不同的数据类型应该正确处理', () => {
+      const accessor = createDataAccessor(0);
+
+      const result1 = accessor([1, 2, 3]);
+      const result2 = accessor({ 0: 'not array' });
+
+      assert.strictEqual(result1, 1);
+      assert.strictEqual(result2, null);
+    });
+  });
+});
+
+describe('createArrayAccessor', () => {
+  it('应该返回数组指定索引的元素', () => {
+    const accessor = createArrayAccessor(0);
+    assert.strictEqual(accessor(['a', 'b', 'c']), 'a');
+
+    const accessor2 = createArrayAccessor(2);
+    assert.strictEqual(accessor2(['a', 'b', 'c']), 'c');
+  });
+
+  it('应该处理负数索引', () => {
+    const accessor = createArrayAccessor(-1);
+    assert.strictEqual(accessor(['a', 'b', 'c']), 'c');
+
+    const accessor2 = createArrayAccessor(-2);
+    assert.strictEqual(accessor2(['a', 'b', 'c']), 'b');
+  });
+
+  it('应该处理越界索引', () => {
+    const accessor = createArrayAccessor(10);
+    assert.strictEqual(accessor(['a', 'b', 'c']), null);
+
+    const accessor2 = createArrayAccessor(-10);
+    assert.strictEqual(accessor2(['a', 'b', 'c']), null);
+  });
+
+  it('应该处理空数组', () => {
+    const accessor = createArrayAccessor(0);
+    assert.strictEqual(accessor([]), null);
+  });
+
+  it('应该返回数组长度', () => {
+    const accessor = createArrayAccessor('length');
+    assert.strictEqual(accessor(['a', 'b', 'c']), 3);
+  });
+
+  it('应该处理无效的字符串索引', () => {
+    const accessor = createArrayAccessor('abc');
+    assert.strictEqual(accessor(['a', 'b', 'c']), null);
+
+    const accessor2 = createArrayAccessor('1.5');
+    assert.strictEqual(accessor2(['a', 'b', 'c']), null);
+  });
+
+  it('应该拒绝浮点数索引', () => {
+    const accessor = createArrayAccessor(1.5);
+    assert.strictEqual(accessor(['a', 'b', 'c']), null);
+  });
+});
+
+describe('createPathAccessor', () => {
+  it('应该访问单个键', () => {
+    const accessor = createPathAccessor(['name']);
+    assert.strictEqual(accessor({ name: 'John' }), 'John');
+  });
+
+  it('应该访问嵌套路径', () => {
+    const accessor = createPathAccessor(['user', 'profile', 'name']);
+    assert.strictEqual(accessor({ user: { profile: { name: 'John' } } }), 'John');
+  });
+
+  it('应该处理不存在的路径', () => {
+    const accessor = createPathAccessor(['nonexistent']);
+    assert.strictEqual(accessor({ name: 'John' }), null);
+  });
+
+    it('应该返回原数据', () => {
+      const accessor = createPathAccessor([]);
+      const input = { name: 'John' };
+      assert.strictEqual(accessor(input), input);
+    });
+
+  it('应该处理数组访问', () => {
+    const accessor = createPathAccessor(['items', '0', 'name']);
+    assert.strictEqual(accessor({ items: [{ name: 'first' }, { name: 'second' }] }), 'first');
+  });
+});
+
+describe('parseDotPath', () => {
+  it('应该解析简单路径', () => {
+    assert.deepStrictEqual(parseDotPath('user.name'), ['user', 'name']);
+    assert.deepStrictEqual(parseDotPath('a.b.c'), ['a', 'b', 'c']);
+  });
+
+  it('应该处理前导点', () => {
+    assert.deepStrictEqual(parseDotPath('.user.name'), ['user', 'name']);
+  });
+
+  it('应该处理空字符串', () => {
+    assert.deepStrictEqual(parseDotPath(''), []);
+  });
+
+  it('应该处理单个段', () => {
+    assert.deepStrictEqual(parseDotPath('name'), ['name']);
+  });
+
+  it('应该处理转义点号', () => {
+    assert.deepStrictEqual(parseDotPath('user\\.name'), ['user.name']);
+    assert.deepStrictEqual(parseDotPath('a\\.b.c'), ['a.b', 'c']);
+  });
+
+  it('应该处理前导点后无内容', () => {
+    assert.deepStrictEqual(parseDotPath('.'), []);
+  });
+});

package/src/createDataAccessor.ts

@@ -0,0 +1,26 @@
+import { createArrayAccessor } from './createArrayAccessor.js';
+import { createPathAccessor } from './createPathAccessor.js';
+import { parseDotPath } from './parseDotPath.js';
+
+export function createDataAccessor(pathname: string | number | null): (data: unknown) => unknown {
+  if (pathname == null) {
+    return () => null;
+  }
+
+  if (typeof pathname === 'number') {
+    const arrayAccessor = createArrayAccessor(pathname);
+    return (data: unknown) => {
+      if (!Array.isArray(data)) {
+        return null;
+      }
+      return arrayAccessor(data);
+    };
+  }
+
+  if (typeof pathname === 'string') {
+    const parsedPath = parseDotPath(pathname);
+    return createPathAccessor(parsedPath);
+  }
+
+  return () => null;
+}