wenay-react2 1.0.45 → 1.0.47

package/lib/native/columnState.js

@@ -0,0 +1,209 @@
+const SCHEMA_V = 1;
+function copy(config) {
+    return {
+        ...config,
+        order: config.order.slice(),
+        visible: { ...config.visible },
+        width: { ...config.width },
+        sort: config.sort ? { ...config.sort } : null,
+        filter: { ...config.filter },
+        groups: Object.fromEntries(Object.entries(config.groups).map(([group, keys]) => [group, keys.slice()])),
+    };
+}
+function pinFixed(order, columns) {
+    const fixed = new Set(columns.filter(column => column.fixed).map(column => column.key));
+    const result = order.filter(key => !fixed.has(key));
+    columns.forEach(function pin(column, index) {
+        if (column.fixed)
+            result.splice(Math.min(index, result.length), 0, column.key);
+    });
+    return result;
+}
+/** Headless, platform-neutral column controller. AsyncStorage satisfies storage directly. */
+export function createNativeColumnState(opts) {
+    const columns = opts.columns.slice();
+    const byKey = new Map(columns.map(column => [column.key, column]));
+    const known = new Set(byKey.keys());
+    const groupKeys = [...new Set(columns.map(column => column.group).filter((group) => !!group))];
+    const listeners = new Set();
+    let revision = 0;
+    let hydrated = !opts.storage;
+    let disposed = false;
+    let timer;
+    let writes = Promise.resolve();
+    const members = (group) => columns.filter(column => column.group == group).map(column => column.key);
+    function defaults() {
+        return {
+            v: SCHEMA_V,
+            order: opts.def?.order?.slice() ?? columns.map(column => column.key),
+            visible: opts.def?.visible ? { ...opts.def.visible } : Object.fromEntries(columns.map(column => [column.key, column.defaultVisible != false])),
+            width: opts.def?.width ? { ...opts.def.width } : {},
+            sort: opts.def?.sort ? { ...opts.def.sort } : null,
+            filter: opts.def?.filter ? { ...opts.def.filter } : {},
+            groups: opts.def?.groups ? { ...opts.def.groups } : Object.fromEntries(groupKeys.map(group => [group, members(group)])),
+        };
+    }
+    function normalize(value) {
+        const base = defaults();
+        const order = (Array.isArray(value?.order) ? value.order : base.order)
+            .filter(key => known.has(key) && !byKey.get(key)?.fixed);
+        for (const column of columns)
+            if (!column.fixed && !order.includes(column.key))
+                order.push(column.key);
+        const rawVisible = value?.visible && typeof value.visible == 'object' ? value.visible : base.visible;
+        const visible = {};
+        for (const column of columns)
+            visible[column.key] = column.fixed ? true : (rawVisible[column.key] ?? column.defaultVisible != false);
+        const width = {};
+        for (const [key, item] of Object.entries(value?.width ?? {}))
+            if (known.has(key) && typeof item == 'number' && isFinite(item) && item > 0)
+                width[key] = item;
+        const sort = value?.sort && known.has(value.sort.key) && (value.sort.dir == 'asc' || value.sort.dir == 'desc')
+            ? { key: value.sort.key, dir: value.sort.dir } : null;
+        const filter = {};
+        for (const [key, item] of Object.entries(value?.filter ?? {}))
+            if (known.has(key))
+                filter[key] = item;
+        const groups = {};
+        for (const group of groupKeys) {
+            const allowed = members(group);
+            const raw = value?.groups?.[group];
+            groups[group] = Array.isArray(raw) ? raw.filter(key => allowed.includes(key)) : allowed;
+        }
+        return { v: SCHEMA_V, order: pinFixed(order, columns), visible, width, sort, filter, groups };
+    }
+    let config = normalize(defaults());
+    const emit = () => {
+        const snapshot = copy(config);
+        for (const listener of listeners)
+            listener(snapshot);
+    };
+    const report = (phase, error) => opts.onError?.({ phase, error });
+    function enqueue(snapshot) {
+        if (!opts.storage || disposed)
+            return;
+        writes = writes.then(async function save() {
+            try {
+                await opts.storage.setItem(opts.key, JSON.stringify(snapshot));
+            }
+            catch (error) {
+                report('write', error);
+            }
+        });
+    }
+    function schedule() {
+        if (!opts.storage || !hydrated || disposed)
+            return;
+        clearTimeout(timer);
+        timer = setTimeout(function saveLater() {
+            timer = undefined;
+            enqueue(copy(config));
+        }, opts.saveMs ?? 100);
+    }
+    function commit(next) {
+        if (disposed)
+            return;
+        config = normalize(next);
+        revision++;
+        emit();
+        schedule();
+    }
+    const ready = (async function hydrate() {
+        if (!opts.storage)
+            return copy(config);
+        const before = revision;
+        try {
+            const raw = await opts.storage.getItem(opts.key);
+            if (raw != null && revision == before) {
+                try {
+                    config = normalize(JSON.parse(raw));
+                    emit();
+                }
+                catch (error) {
+                    report('parse', error);
+                }
+            }
+        }
+        catch (error) {
+            report('read', error);
+        }
+        finally {
+            hydrated = true;
+            if (revision != before)
+                schedule();
+        }
+        return copy(config);
+    })();
+    const getConfig = () => copy(config);
+    const subscribe = (listener) => {
+        listeners.add(listener);
+        return function unsubscribe() { listeners.delete(listener); };
+    };
+    function show(key, visible) {
+        if (!known.has(key) || byKey.get(key)?.fixed)
+            return;
+        commit({ ...config, visible: { ...config.visible, [key]: visible } });
+    }
+    function move(order) { commit({ ...config, order }); }
+    function moveKey(key, to) {
+        if (!known.has(key) || byKey.get(key)?.fixed)
+            return;
+        const order = config.order.slice();
+        const from = order.indexOf(key);
+        if (from == -1)
+            return;
+        order.splice(from, 1);
+        order.splice(Math.max(0, Math.min(order.length, to)), 0, key);
+        move(order);
+    }
+    function setSort(sort) { commit({ ...config, sort }); }
+    function toggleSort(key) {
+        if (!known.has(key))
+            return;
+        const current = config.sort;
+        setSort(current?.key != key ? { key, dir: 'asc' } : current.dir == 'asc' ? { key, dir: 'desc' } : null);
+    }
+    function setFilter(key, value) {
+        if (!known.has(key))
+            return;
+        const filter = { ...config.filter };
+        if (value == null)
+            delete filter[key];
+        else
+            filter[key] = value;
+        commit({ ...config, filter });
+    }
+    function setGroup(group, keys) {
+        if (!groupKeys.includes(group))
+            return;
+        commit({ ...config, groups: { ...config.groups, [group]: keys } });
+    }
+    function visibleKeys() {
+        return config.order.filter(key => {
+            if (config.visible[key] == false)
+                return false;
+            const group = byKey.get(key)?.group;
+            return !group || config.groups[group]?.includes(key);
+        });
+    }
+    function reset() { commit(defaults()); }
+    async function flush() {
+        clearTimeout(timer);
+        timer = undefined;
+        await ready;
+        enqueue(copy(config));
+        await writes;
+    }
+    function dispose() {
+        disposed = true;
+        clearTimeout(timer);
+        listeners.clear();
+    }
+    return {
+        columns: columns,
+        ready,
+        api: { getConfig, setConfig: (next) => commit(next), subscribe, show, move, moveKey,
+            setSort, toggleSort, setFilter, setGroup, visibleKeys, reset, flush },
+        dispose,
+    };
+}

package/lib/native/index.d.ts

@@ -0,0 +1,3 @@
+/** DOM/CSS/ag-grid/react-dom-free React Native entrypoint. */
+export * from './columnState.js';
+export * from './columnDots.js';

package/lib/native/index.js

@@ -0,0 +1,3 @@
+/** DOM/CSS/ag-grid/react-dom-free React Native entrypoint. */
+export * from './columnState.js';
+export * from './columnDots.js';

package/lib/style/style.css

@@ -1058,6 +1058,30 @@ body {
   color: var(--cols-card-accent-color, #0969da);
   white-space: nowrap;
 }
+.wenayCardListFields {
+  display: block;
+}
+.wenayCardListItem_compact .wenayCardListFields {
+  display: grid;
+  grid-template-columns: repeat(2, minmax(0, 1fr));
+  gap: 4px 8px;
+}
+.wenayCardListItem_compact .wenayCardListField {
+  min-width: 0;
+  padding: 2px 6px;
+  border-radius: 5px;
+  background: var(--cols-card-field-bg, #f6f8fa);
+  line-height: 1.45;
+}
+.wenayCardListItem_compact .wenayCardListLabel {
+  min-width: 0;
+  font-size: 10px;
+  text-transform: uppercase;
+  letter-spacing: .03em;
+}
+@media (max-width: 320px) {
+  .wenayCardListItem_compact .wenayCardListFields { grid-template-columns: 1fr; }
+}
 .wenayCardListField {
   display: flex;
   gap: var(--cols-card-field-gap, 10px);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wenay-react2",
-  "version": "1.0.45",
+  "version": "1.0.47",
   "description": "Common react",
   "strict": true,
   "main": "dist/index.js",
@@ -24,7 +24,7 @@
     "react": "^19.2.0",
     "react-dom": "^19.2.0",
     "react-rnd": "^10.5.3",
-    "wenay-common2": "^1.0.73"
+    "wenay-common2": "^1.0.74"
   },
   "peerDependencies": {
     "react": "^19.2.0",
@@ -45,6 +45,9 @@
   },
   "exports": {
     ".": "./lib/index.js",
-    "./package.json": "./package.json"
+    "./native": "./lib/native/index.js",
+    "./package.json": "./package.json",
+    "./demo/peer-media": "./lib/common/demo/peerMedia.js",
+    "./demo/stand": "./lib/common/testUseReact/qa.js"
   }
 }