@yanqirenshi/table.wbs 0.0.17 → 0.0.19

package/example/package.json

@@ -6,16 +6,19 @@
         "@testing-library/jest-dom": "^6.4.6",
         "@testing-library/react": "^16.0.0",
         "@testing-library/user-event": "^14.5.2",
-        "@yanqirenshi/table.wbs": "file:..",
+        "@yanqirenshi/table.wbs": "file:yanqirenshi-table.wbs-0.0.18.tgz",
         "moment": "^2.27.0",
         "react": "^19.0.0",
         "react-dom": "^19.0.0",
         "react-router-dom": "^5.2.0",
         "react-scripts": "3.4.1"
     },
+    "devDependencies": {
+        "cross-env": "^7.0.3"
+    },
     "scripts": {
-        "start": "react-scripts start",
-        "build": "react-scripts build",
+        "start": "cross-env NODE_OPTIONS=--openssl-legacy-provider react-scripts start",
+        "build": "cross-env NODE_OPTIONS=--openssl-legacy-provider react-scripts build",
         "test": "react-scripts test",
         "eject": "react-scripts eject"
     },

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@yanqirenshi/table.wbs",
-    "version": "0.0.17",
+    "version": "0.0.19",
     "description": "See: examples/",
     "main": "dist/index.js",
     "directories": {

package/tests/Core.filter.test.js

@@ -0,0 +1,51 @@
+import Core from '../src/Core.js';
+
+const core = new Core();
+
+// 1
+// ├ 20
+// │  ├ 22
+// │  │  └ 220 (wp)
+// │  └ 21
+// │     ├ 210 (wp)
+// │     └ 211 (wp)
+// └ 10
+//    └ 100 (wp)
+const wp = (_id, _level, label) => ({ _id, _level, _class: 'WORKPACKAGE', label, _core: { label } });
+const wbs = (_id, _level, label) => ({ _id, _level, _class: 'WBS', label, _core: { label } });
+
+const records = [
+    wbs(1,   0, 'project'),
+    wbs(20,  1, 'design'),
+    wbs(22,  2, 'detail'),
+    wp(220,  3, 'api'),
+    wbs(21,  2, 'basic'),
+    wp(210,  3, 'screen'),
+    wp(211,  3, 'db'),
+    wbs(10,  1, 'requirements'),
+    wp(100,  2, 'survey'),
+];
+
+const ids = (list) => list.map(d => d._id);
+
+describe('applyFilter (collapse)', () => {
+    test('shows everything when nothing is closed', () => {
+        expect(ids(core.applyFilter('', {}, records))).toEqual([1, 20, 22, 220, 21, 210, 211, 10, 100]);
+    });
+    test('hides the descendants of a closed node but keeps the node itself', () => {
+        expect(ids(core.applyFilter('', { 21: true }, records))).toEqual([1, 20, 22, 220, 21, 10, 100]);
+    });
+    test('a closed node inside a closed ancestor stays hidden', () => {
+        // 21 を閉じてから 20 を閉じる → 21 は 20 の中なので見えてはいけない
+        expect(ids(core.applyFilter('', { 21: true, 20: true }, records))).toEqual([1, 20, 10, 100]);
+    });
+    test('siblings after a closed subtree are shown again', () => {
+        expect(ids(core.applyFilter('', { 20: true }, records))).toEqual([1, 20, 10, 100]);
+    });
+});
+
+describe('applyFilter (workpackage filter)', () => {
+    test('keeps only matching workpackages, case-insensitively, and all WBS rows', () => {
+        expect(ids(core.applyFilter('API', {}, records))).toEqual([1, 20, 22, 220, 21, 10]);
+    });
+});

package/tests/Core.selection.test.js

@@ -0,0 +1,49 @@
+import Core from '../src/Core.js';
+
+const core = new Core();
+
+const records = [
+    { _id: 1,   _class: 'PROJECT',     _level: 0 },
+    { _id: 10,  _class: 'WBS',         _level: 1 },
+    { _id: 100, _class: 'WORKPACKAGE', _level: 2 },
+];
+
+describe('toggleSelected (single)', () => {
+    test('selects the clicked row and replaces any previous selection', () => {
+        expect(core.toggleSelected(10, {}, 'single')).toEqual({ 10: true });
+        expect(core.toggleSelected(100, { 10: true }, 'single')).toEqual({ 100: true });
+    });
+    test('clicking the selected row again clears the selection', () => {
+        expect(core.toggleSelected(10, { 10: true }, 'single')).toEqual({});
+    });
+    test('does not mutate the given object', () => {
+        const before = { 10: true };
+        core.toggleSelected(100, before, 'single');
+        expect(before).toEqual({ 10: true });
+    });
+});
+
+describe('toggleSelected (multiple)', () => {
+    test('adds rows to the selection', () => {
+        expect(core.toggleSelected(10, {}, 'multiple')).toEqual({ 10: true });
+        expect(core.toggleSelected(100, { 10: true }, 'multiple')).toEqual({ 10: true, 100: true });
+    });
+    test('removes a row that is already selected', () => {
+        expect(core.toggleSelected(10, { 10: true, 100: true }, 'multiple')).toEqual({ 100: true });
+    });
+    test('does not mutate the given object', () => {
+        const before = { 10: true };
+        core.toggleSelected(100, before, 'multiple');
+        expect(before).toEqual({ 10: true });
+    });
+});
+
+describe('selectedIds / selectedRecords', () => {
+    test('selectedIds returns numeric ids', () => {
+        expect(core.selectedIds({ 10: true, 100: true }).sort((a, b) => a - b)).toEqual([10, 100]);
+        expect(core.selectedIds({})).toEqual([]);
+    });
+    test('selectedRecords keeps record order', () => {
+        expect(core.selectedRecords({ 100: true, 1: true }, records).map(d => d._id)).toEqual([1, 100]);
+    });
+});

package/tests/Core.width.test.js

@@ -0,0 +1,70 @@
+import Core from '../src/Core.js';
+
+const core = new Core();
+
+const columns = core.makeColumns([
+    { label: 'Code', leveling: true },
+    { label: 'Name', width: { min: 100 } },
+    { label: 'Description' },
+]);
+
+describe('makeColumns', () => {
+    test('gives every column a width with min/max defaulting to null', () => {
+        expect(columns[0].width).toEqual({ min: null, max: null });
+        expect(columns[2].width).toEqual({ min: null, max: null });
+    });
+    test('keeps width given in the seed', () => {
+        expect(columns[1].width).toEqual({ min: 100, max: null });
+    });
+});
+
+describe('changeColumnWidth', () => {
+    test('sets min/max on the target column only and does not mutate the input', () => {
+        const out = core.changeColumnWidth(2, 'max', 300, columns);
+
+        expect(out[2].width).toEqual({ min: null, max: 300 });
+        expect(out[0]).toBe(columns[0]);
+        expect(out[1]).toBe(columns[1]);
+        expect(columns[2].width).toEqual({ min: null, max: null });
+    });
+    test('accepts numeric strings from inputs', () => {
+        expect(core.changeColumnWidth(1, 'max', '250', columns)[1].width).toEqual({ min: 100, max: 250 });
+    });
+    test('treats empty, NaN and non-positive values as unset', () => {
+        expect(core.changeColumnWidth(1, 'min', '', columns)[1].width.min).toBeNull();
+        expect(core.changeColumnWidth(1, 'min', 'abc', columns)[1].width.min).toBeNull();
+        expect(core.changeColumnWidth(1, 'min', 0, columns)[1].width.min).toBeNull();
+        expect(core.changeColumnWidth(1, 'min', -5, columns)[1].width.min).toBeNull();
+    });
+});
+
+describe('widthCellStyle / fitsFullWidth', () => {
+    test('widthCellStyle pins the column width to max, nothing otherwise', () => {
+        expect(core.widthCellStyle(columns[1])).toEqual({});
+        expect(core.widthCellStyle(core.changeColumnWidth(1, 'max', 120, columns)[1])).toEqual({ width: 120 });
+    });
+    test('fitsFullWidth is false only when every column has a max', () => {
+        expect(core.fitsFullWidth(columns)).toBe(true);
+
+        let all = columns;
+        for (const c of columns)
+            all = core.changeColumnWidth(c.number, 'max', 100, all);
+
+        expect(core.fitsFullWidth(all)).toBe(false);
+        expect(core.fitsFullWidth(core.changeColumnWidth(2, 'max', '', all))).toBe(true);
+    });
+});
+
+describe('widthStyle', () => {
+    test('returns an empty style when nothing is set', () => {
+        expect(core.widthStyle(columns[0])).toEqual({});
+        expect(core.widthStyle({ label: 'x' })).toEqual({});
+    });
+    test('maps min to minWidth', () => {
+        expect(core.widthStyle(columns[1])).toEqual({ minWidth: 100 });
+    });
+    test('maps max to maxWidth and enables word breaking', () => {
+        const c = core.changeColumnWidth(2, 'max', 300, columns)[2];
+        expect(core.widthStyle(c)).toEqual({ maxWidth: 300, overflowWrap: 'break-word' });
+    });
+});

package/tests/Supporter.test.js

@@ -0,0 +1,115 @@
+import React from 'react';
+
+import Supporter from '../src/Supporter.js';
+
+const wbs = { _id: 10, _class: 'WBS', _level: 1, label: 'b', description: 'desc-b' };
+const wp  = { _id: 100, _class: 'WORKPACKAGE', _node_type: 'DB_TABLE', _level: 2,
+              label: 'c', _core: { physical_name: 'T_C', use: true } };
+
+describe('margin', () => {
+    test('default indent is a full-width space per level', () => {
+        const s = new Supporter();
+        expect(s.margin(0)).toBe('');
+        expect(s.margin(3)).toBe('　　　');
+    });
+    test('indent can be customized', () => {
+        const s = new Supporter({ indent: '--' });
+        expect(s.margin(2)).toBe('----');
+    });
+});
+
+describe('path / to', () => {
+    test('falls back to defaultPath when the node type is unknown', () => {
+        const s = new Supporter();
+        expect(s.to(wbs)).toBe('/wbs/10');
+    });
+    test('uses _node_type before _class to look up paths', () => {
+        const s = new Supporter({ paths: { DB_TABLE: 'database/tables', WORKPACKAGE: 'wp' } });
+        expect(s.to(wp)).toBe('/database/tables/100');
+    });
+    test('defaultPath can be customized', () => {
+        const s = new Supporter({ defaultPath: 'nodes' });
+        expect(s.to(wbs)).toBe('/nodes/10');
+    });
+});
+
+describe('cellID', () => {
+    test('returns the raw _id when no link renderer is given', () => {
+        const s = new Supporter();
+        expect(s.cellID({}, wbs)).toBe(10);
+        expect(s.cellIDNotLink({}, wbs)).toBe(10);
+    });
+    test('delegates to the link renderer with (to, label, data)', () => {
+        const link = jest.fn((to, label) => `${label}@${to}`);
+        const s = new Supporter({ link: link });
+
+        expect(s.cellID({}, wbs)).toBe('10@/wbs/10');
+        expect(link).toHaveBeenCalledWith('/wbs/10', 10, wbs);
+    });
+    test('methods are bound so they can be passed as contents directly', () => {
+        const s = new Supporter({ link: (to, label) => `${label}@${to}` });
+        const contents = s.cellID;
+        expect(contents({}, wbs)).toBe('10@/wbs/10');
+    });
+});
+
+describe('cellLabel / cellDescription / cellValue / cellCoreValue', () => {
+    const s = new Supporter({ empty: '-' });
+
+    test('cellLabel returns label', () => {
+        expect(s.cellLabel({}, wbs)).toBe('b');
+    });
+    test('cellDescription returns description or empty mark', () => {
+        expect(s.cellDescription({}, wbs)).toBe('desc-b');
+        expect(s.cellDescription({}, wp)).toBe('-');
+    });
+    test('cellValue reads data[key]', () => {
+        expect(s.cellValue('label')({}, wp)).toBe('c');
+        expect(s.cellValue('nothing')({}, wp)).toBe('-');
+    });
+    test('cellCoreValue reads data._core[key]', () => {
+        expect(s.cellCoreValue('physical_name')({}, wp)).toBe('T_C');
+        expect(s.cellCoreValue('physical_name')({}, wbs)).toBe('-');
+    });
+});
+
+describe('cellFlag', () => {
+    test('shows ○ for true and -- otherwise, looking in data then _core', () => {
+        const s = new Supporter();
+        const f = s.cellFlag('use');
+        expect(f({}, wp)).toBe('○');
+        expect(f({}, wbs)).toBe('--');
+        expect(f({}, { use: true })).toBe('○');
+        expect(f({}, { use: 'yes' })).toBe('--');
+    });
+    test('marks can be customized globally and per cell', () => {
+        const s = new Supporter({ marks: { true: 'Y', false: 'N' } });
+        expect(s.cellFlag('use')({}, wp)).toBe('Y');
+        expect(s.cellFlag('use', { false: '×' })({}, wbs)).toBe('×');
+    });
+});
+
+describe('cellByType', () => {
+    test('switches contents by node type and falls back to cellLabel', () => {
+        const s = new Supporter();
+        const f = s.cellByType({ DB_TABLE: s.cellCoreValue('physical_name') });
+        expect(f({}, wp)).toBe('T_C');
+        expect(f({}, wbs)).toBe('b');
+    });
+    test('custom fallback is used for unmatched types', () => {
+        const s = new Supporter();
+        const f = s.cellByType({}, () => '---');
+        expect(f({}, wbs)).toBe('---');
+    });
+});
+
+describe('withMargin', () => {
+    test('wraps contents with a level-based indent', () => {
+        const s = new Supporter();
+        const el = s.withMargin(s.cellLabel)({}, wp, 0);
+        const [margin, body] = el.props.children;
+
+        expect(margin.props.children).toBe('　　');
+        expect(body.props.children).toBe('c');
+    });
+});

package/.claude/settings.local.json

@@ -1,17 +0,0 @@
-{
-  "permissions": {
-    "allow": [
-      "Bash(node -e \"console.log\\(require\\('./node_modules/react/package.json'\\).version\\)\")",
-      "Bash(npm install *)",
-      "Bash(npm test *)",
-      "Bash(git stash *)",
-      "Bash(npm view *)",
-      "Bash(npx react-scripts *)",
-      "Bash(SKIP_PREFLIGHT_CHECK=true CI=true npx react-scripts test --watchAll=false)",
-      "Bash(SKIP_PREFLIGHT_CHECK=true CI=true npx react-scripts build)",
-      "Bash(SKIP_PREFLIGHT_CHECK=true BROWSER=none npx react-scripts start)",
-      "Bash(kill %1)",
-      "Bash(wait)"
-    ]
-  }
-}