wenay-react2 1.0.35 → 1.0.36

package/lib/common/src/utils/{mapMemory.d.ts → memoryStore.d.ts}

@@ -1,32 +1,32 @@
 import { ObservableMap } from "./observableMap";
-export declare function staticSet(key: any, data: object): void;
-export declare function staticGet(key: any): object | undefined;
+export declare function memorySet(key: any, data: object): void;
+export declare function memoryGet(key: any): object | undefined;
 export declare function deepMergeWithMap(target: any, source: any, visited?: Map<any, any>): any;
-export declare function staticGetAdd<T extends object>(key: any, def: T, options?: {
+export declare function memoryGetOrCreate<T extends object>(key: any, def: T, options?: {
     abs?: boolean;
     deepAutoMerge?: boolean;
     reversDeep?: boolean;
 }): T;
-/** Announce a direct in-place mutation of an object taken from staticGetAdd - such
- *  mutations are invisible to map methods. staticSet/staticGetAdd need no announcement:
- *  their set() calls are observed by Cash automatically. */
-export declare function staticMarkDirty(key: any): void;
-/** App-facing change of a persisted staticProps entry in one call:
+/** Announce a direct in-place mutation of an object taken from memoryGetOrCreate - such
+ *  mutations are invisible to map methods. memorySet/memoryGetOrCreate need no announcement:
+ *  their set() calls are observed by memoryCache automatically. */
+export declare function memoryMarkDirty(key: any): void;
+/** App-facing change of a persisted memoryProps entry in one call:
  *  mutate + rerender subscribers + mark the cache dirty. No-op if the key is absent. */
-export declare function staticUpdate<T extends object>(key: any, mutate: (cur: T) => void): T | undefined;
-export declare function staticGetById<T extends object>(key: any, def: T, id: string | number): T;
-export declare const Cash: {
+export declare function memoryUpdate<T extends object>(key: any, mutate: (cur: T) => void): T | undefined;
+export declare function memoryGetById<T extends object>(key: any, def: T, id: string | number): T;
+export declare const memoryCache: {
     load(): Promise<void>;
     save(): Promise<void>;
     saveDebounced(delay?: number): void;
     flush(): Promise<void>;
     clear(): Promise<void>;
     markDirty: (scope?: string, key?: string) => void;
-    onDirty(cb: import("./cache").tDirtyListener): () => void;
+    onDirty(cb: import("./cache").DirtyListener): () => void;
     isDirty(): boolean;
     getArr: [k: string, v: Map<string, unknown>][];
 };
-export declare const MemoryMap: {
+export declare const memoryMaps: {
     rnd: ObservableMap<string, {
         position: {
             x: number;

package/lib/common/src/utils/{mapMemory.js → memoryStore.js}

@@ -1,18 +1,18 @@
 import { deepClone } from "wenay-common2";
 import { renderBy } from "../../updateBy";
-import { ExRNDMap3 } from "../components/Dnd/RNDFunc3";
+import { floatingWindowMap } from "../components/Dnd/FloatingWindow";
 import { mapResiReact } from "../components/Dnd/Resizable";
 import { mapRightMenu } from "../components/Menu/RightMenuStore";
-import { CacheFuncMap } from "./cache";
+import { createCacheMap } from "./cache";
 import { ObservableMap } from "./observableMap";
-// observable - Cash marks itself dirty on its mutations
-const staticProps = new ObservableMap();
-export function staticSet(key, data) {
-    if (!staticProps.has(key))
-        staticProps.set(key, data);
+// observable - memoryCache marks itself dirty on its mutations
+const memoryProps = new ObservableMap();
+export function memorySet(key, data) {
+    if (!memoryProps.has(key))
+        memoryProps.set(key, data);
 }
-export function staticGet(key) {
-    return staticProps.get(key);
+export function memoryGet(key) {
+    return memoryProps.get(key);
 }
 function isObject(item) {
     return item !== null && typeof item === 'object' && !Array.isArray(item);
@@ -42,54 +42,54 @@ export function deepMergeWithMap(target, source, visited = new Map()) {
 }
 // WeakSet: a strict Map kept every def object alive forever
 const merged = new WeakSet();
-export function staticGetAdd(key, def, options = { reversDeep: false }) {
+export function memoryGetOrCreate(key, def, options = { reversDeep: false }) {
     if (options.deepAutoMerge && !merged.has(def)) {
         merged.add(def);
         if (!options.reversDeep)
-            staticProps.set(key, deepMergeWithMap(staticProps.get(key) ?? {}, def));
+            memoryProps.set(key, deepMergeWithMap(memoryProps.get(key) ?? {}, def));
         else
-            staticProps.set(key, deepMergeWithMap(deepClone(def), staticProps.get(key) ?? {}));
+            memoryProps.set(key, deepMergeWithMap(deepClone(def), memoryProps.get(key) ?? {}));
     }
     if (options.abs)
-        staticProps.set(key, def);
-    const t = (staticProps.has(key) ? staticProps.get(key) : staticProps.set(key, def).get(key));
+        memoryProps.set(key, def);
+    const t = (memoryProps.has(key) ? memoryProps.get(key) : memoryProps.set(key, def).get(key));
     return t; // Object.assign(def, t) // t //
 }
-/** Announce a direct in-place mutation of an object taken from staticGetAdd - such
- *  mutations are invisible to map methods. staticSet/staticGetAdd need no announcement:
- *  their set() calls are observed by Cash automatically. */
-export function staticMarkDirty(key) {
-    staticProps.touch(typeof key == "string" ? key : undefined);
+/** Announce a direct in-place mutation of an object taken from memoryGetOrCreate - such
+ *  mutations are invisible to map methods. memorySet/memoryGetOrCreate need no announcement:
+ *  their set() calls are observed by memoryCache automatically. */
+export function memoryMarkDirty(key) {
+    memoryProps.touch(typeof key == "string" ? key : undefined);
 }
-/** App-facing change of a persisted staticProps entry in one call:
+/** App-facing change of a persisted memoryProps entry in one call:
  *  mutate + rerender subscribers + mark the cache dirty. No-op if the key is absent. */
-export function staticUpdate(key, mutate) {
-    const cur = staticProps.get(key);
+export function memoryUpdate(key, mutate) {
+    const cur = memoryProps.get(key);
     if (cur === undefined)
         return undefined;
     mutate(cur);
     renderBy(cur);
-    staticMarkDirty(key);
+    memoryMarkDirty(key);
     return cur;
 }
-export function staticGetById(key, def, id) {
-    const stored = staticProps.get(key);
+export function memoryGetById(key, def, id) {
+    const stored = memoryProps.get(key);
     if (!stored || stored.__id !== id) {
         const fresh = { __id: id, data: def };
-        staticProps.set(key, fresh);
+        memoryProps.set(key, fresh);
         return fresh.data;
     }
     return stored.data;
 }
-export const Cash = CacheFuncMap([
+export const memoryCache = createCacheMap([
     ["mapResiReact", mapResiReact],
-    ["ExRNDMap3", ExRNDMap3],
+    ["floatingWindowMap", floatingWindowMap],
     ["mapRightMenu", mapRightMenu],
-    ["staticProps", staticProps]
+    ["memoryProps", memoryProps]
 ]);
-export const MemoryMap = {
-    rnd: ExRNDMap3,
+export const memoryMaps = {
+    rnd: floatingWindowMap,
     resize: mapResiReact,
     rightMenu: mapRightMenu,
-    other: staticProps
+    other: memoryProps
 };

package/lib/common/src/utils/observableMap.d.ts

@@ -1,13 +1,13 @@
-/** Map that announces its own mutations. The persisted-state maps (ExRNDMap3, mapResiReact,
- *  mapRightMenu, staticProps) are ObservableMap instances, so the dirty signal originates in
+/** Map that announces its own mutations. The persisted-state maps (floatingWindowMap, mapResiReact,
+ *  mapRightMenu, memoryProps) are ObservableMap instances, so the dirty signal originates in
  *  the data layer itself: set/delete/clear emit automatically, touch(key) announces an
- *  in-place mutation of a stored object (invisible to map methods). CacheFuncMapBase
+ *  in-place mutation of a stored object (invisible to map methods). createCacheMapWithStorage
  *  subscribes to the maps it owns - mutation sites never talk to the cache directly. */
-export type tMapChangeListener<K> = (key?: K) => void;
+export type MapChangeListener<K> = (key?: K) => void;
 export declare class ObservableMap<K, V> extends Map<K, V> {
     private listeners?;
     /** Subscribe to mutations (set/delete/clear/touch); returns unsubscribe. */
-    onChange(cb: tMapChangeListener<K>): () => void;
+    onChange(cb: MapChangeListener<K>): () => void;
     /** Announce an in-place mutation of a stored value. */
     touch(key?: K): void;
     private emit;

package/lib/common/src/utils/observableMap.js

@@ -1,7 +1,7 @@
-/** Map that announces its own mutations. The persisted-state maps (ExRNDMap3, mapResiReact,
- *  mapRightMenu, staticProps) are ObservableMap instances, so the dirty signal originates in
+/** Map that announces its own mutations. The persisted-state maps (floatingWindowMap, mapResiReact,
+ *  mapRightMenu, memoryProps) are ObservableMap instances, so the dirty signal originates in
  *  the data layer itself: set/delete/clear emit automatically, touch(key) announces an
- *  in-place mutation of a stored object (invisible to map methods). CacheFuncMapBase
+ *  in-place mutation of a stored object (invisible to map methods). createCacheMapWithStorage
  *  subscribes to the maps it owns - mutation sites never talk to the cache directly. */
 export class ObservableMap extends Map {
     // no initializer: Map's constructor calls this.set() before class fields are assigned

package/lib/common/updateBy.js

@@ -1,12 +1,12 @@
 import { useCallback, useLayoutEffect, useSyncExternalStore } from "react";
-import { UseListen, waitRun } from "wenay-common2";
+import { listen as createListen, waitRun } from "wenay-common2";
 export const map3 = new WeakMap();
 export const mapWait = new Map();
 const updateListens = new WeakMap();
 function getUpdateListen(obj) {
     let listen = updateListens.get(obj);
     if (!listen) {
-        listen = UseListen();
+        listen = createListen();
         updateListens.set(obj, listen);
     }
     return listen;

package/lib/style/style.css

@@ -319,7 +319,7 @@ body {
   margin-left: -1px;
 }
 
-/* DivRnd3 window chrome. All visuals go through --wnd-* tokens (tokens.css);
+/* FloatingWindow window chrome. All visuals go through --wnd-* tokens (tokens.css);
    defaults reproduce the legacy look, apps re-skin via :root[data-theme] token overrides. */
 .wenayWnd {
   background: var(--wnd-bg);
@@ -350,7 +350,7 @@ body {
   background: var(--wnd-header-stripes);
 }
 
-/* Window close button (DivRnd3 and others) */
+/* Window close button (FloatingWindow and others) */
 .wenayCloseBtn {
   width: var(--wnd-close-size, 28px);
   height: var(--wnd-close-size, 28px);
@@ -378,7 +378,7 @@ body {
 .wenayCloseBtn:active {
   transform: scale(0.95);
 }
-/* Positioning of the close button inside DivRnd3. Kept separate from .wenayCloseBtn,
+/* Positioning of the close button inside FloatingWindow. Kept separate from .wenayCloseBtn,
    which may be used outside windows and must not become position:absolute there. */
 .wenayWndClose {
   position: absolute;

package/lib/style/tokens.css

@@ -32,7 +32,7 @@
   /* Menu shadow (was a literal in .MenuR) */
   --menu-shadow: 0 0 20px 14px rgba(34, 60, 80, 0.2);
 
-  /* Window (DivRnd3) chrome. Defaults = legacy look, so apps without themes do not change.
+  /* Window (FloatingWindow) chrome. Defaults = legacy look, so apps without themes do not change.
      Apps re-skin via :root[data-theme='...'] overrides, same contract as --color-* / --menu-*.
      Intentionally NOT declared here (fall back to inherit/auto until a theme declares them):
      --wnd-header-height, --wnd-header-color, --wnd-header-font-size,

package/package.json

@@ -1,49 +1,49 @@
-{
-  "name": "wenay-react2",
-  "version": "1.0.35",
-  "description": "Common react",
-  "strict": true,
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "files": [
-    "lib/**/*",
-    "!**/*.tsbuildinfo"
-  ],
-  "author": "wenay",
-  "license": "ISC",
-  "peerDependenciesMeta": {
-    "react-dom": {
-      "optional": true
-    }
-  },
-  "dependencies": {
-    "ag-grid-community": "^35.1.0",
-    "ag-grid-react": "^35.1.0",
-    "re-resizable": "^6.11.2",
-    "react": "^19.2.0",
-    "react-dom": "^19.2.0",
-    "react-rnd": "^10.5.3",
-    "wenay-common2": "^1.0.61"
-  },
-  "peerDependencies": {
-    "react": "^19.2.0",
-    "react-dom": "^19.2.0"
-  },
-  "engines": {
-    "node": ">=18",
-    "vscode": "^1.22.0"
-  },
-  "browserslist": {
-    "production": [
-      ">0.2%",
-      "not dead"
-    ],
-    "development": [
-      ">1%"
-    ]
-  },
-  "exports": {
-    ".": "./lib/index.js",
-    "./package.json": "./package.json"
-  }
-}
+{
+  "name": "wenay-react2",
+  "version": "1.0.36",
+  "description": "Common react",
+  "strict": true,
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "lib/**/*",
+    "!**/*.tsbuildinfo"
+  ],
+  "author": "wenay",
+  "license": "ISC",
+  "peerDependenciesMeta": {
+    "react-dom": {
+      "optional": true
+    }
+  },
+  "dependencies": {
+    "ag-grid-community": "^35.1.0",
+    "ag-grid-react": "^35.1.0",
+    "re-resizable": "^6.11.2",
+    "react": "^19.2.0",
+    "react-dom": "^19.2.0",
+    "react-rnd": "^10.5.3",
+    "wenay-common2": "^1.0.64"
+  },
+  "peerDependencies": {
+    "react": "^19.2.0",
+    "react-dom": "^19.2.0"
+  },
+  "engines": {
+    "node": ">=18",
+    "vscode": "^1.22.0"
+  },
+  "browserslist": {
+    "production": [
+      ">0.2%",
+      "not dead"
+    ],
+    "development": [
+      ">1%"
+    ]
+  },
+  "exports": {
+    ".": "./lib/index.js",
+    "./package.json": "./package.json"
+  }
+}

package/lib/common/src/components/Dnd/DraggableOutlineDiv.d.ts

@@ -1,2 +0,0 @@
-/** @deprecated Demo component with hardcoded content; used only by the test SubMenu. Will be removed in a major version. */
-export declare function DraggableOutlineDiv(): import("react/jsx-runtime").JSX.Element;

package/lib/common/src/hooks/useAddDownAnyKey.d.ts

@@ -1,24 +0,0 @@
-export declare const KeyDown: {
-    key: string;
-};
-export type AnyKeyDownApi = {
-    readonly key: string;
-    getKey(): string;
-    get(): string;
-    clear(): void;
-    reset(): void;
-    subscribe(listener: (key: string, event?: KeyboardEvent) => void): () => void;
-    on(listener: (key: string, event?: KeyboardEvent) => void): () => void;
-};
-export declare const keyDownApi: AnyKeyDownApi;
-export declare function useAddDownAnyKey(options?: {
-    enabled?: boolean;
-    target?: Document | HTMLElement;
-    onKeyDown?: (key: string, event: KeyboardEvent) => void;
-}): AnyKeyDownApi;
-export declare const useKeyDown: typeof useAddDownAnyKey;
-export declare const useAnyKey: typeof useAddDownAnyKey;
-/** @deprecated Use `useKeyDown(options)` or `useAnyKey(options)`. */
-export declare function addDownAnyKey(): AnyKeyDownApi;
-/** @deprecated Use `useKeyDown(options)` or `useAnyKey(options)`. */
-export declare const useAddDownAnyKeyOld: typeof useAddDownAnyKey;

package/lib/common/src/utils/applyTransactionAsyncUpdate.d.ts

@@ -1,53 +0,0 @@
-import { ColDef, GridReadyEvent } from "ag-grid-community";
-declare const optionsDef: {
-    update: boolean;
-    add: boolean;
-    updateBuffer: boolean;
-    sync: boolean;
-};
-type options = Partial<typeof optionsDef>;
-/**
- * @deprecated v1: does not support row removal and silently loses data while the grid is not ready.
- * Use `useAgGrid`/`createGridBuffer` (grid/agGrid4) - buffer + attach/sync,
- * or at least `applyTransactionAsyncUpdate2`.
- */
-export declare function applyTransactionAsyncUpdate<T>(grid: GridReadyEvent<T, any> | null | undefined, newData: (Partial<T>)[], getId: (...a: any[]) => string, bufTable: {
-    [id: string]: Partial<T>;
-}, option?: options): void;
-/** @deprecated No-op stub: always returns {}. Never implemented; will be removed in a major version. */
-export declare function getUpdateTable<T>(grid: GridReadyEvent<T, any> | null | undefined, newData: (Partial<T>)[], getId: (...a: any[]) => string, bufTable: {
-    [id: string]: Partial<T>;
-}, option?: options): {};
-type CommonParams<T> = {
-    getId: (...a: any[]) => string;
-    bufTable: {
-        [id: string]: Partial<T>;
-    };
-    option?: options;
-};
-type params<T> = CommonParams<T> & ({
-    newData?: (Partial<T>)[];
-    removeData?: (Partial<T>)[];
-    synchronization?: never;
-    gridRef?: React.RefObject<GridReadyEvent<T, any> | null | undefined>;
-    grid?: GridReadyEvent<T, any> | null | undefined;
-    onlyMemo?: boolean;
-} | ({
-    newData?: never;
-    removeData?: never;
-    synchronization: true;
-    onlyMemo?: never;
-} & ({
-    grid: GridReadyEvent<T, any> | null | undefined;
-    gridRef?: never;
-} | {
-    gridRef: React.RefObject<GridReadyEvent<T, any> | null | undefined>;
-    grid?: never;
-})));
-export declare function applyTransactionAsyncUpdate2<T>(params: params<T>): void;
-type UnUndefined<T extends (any | undefined)> = T extends undefined ? never : T;
-type t1<T = any> = ColDef<T>["comparator"];
-type paramsCompare<TData = any> = Parameters<Extract<UnUndefined<t1>, (...args: any) => any>>;
-/** @deprecated Duplicate of `numericComparator` from grid/agGrid4 (core.ts) - use that instead. */
-export declare function getComparatorGrid<T = any>(func?: (...param: paramsCompare<T>) => [a: number, b: number]): t1;
-export {};