@guiexpert/table 1.1.17 → 1.1.20

package/dist/lib/common/decorator/avoid-double-execution.decorator.d.ts

@@ -0,0 +1,7 @@
+/**
+ * A decorator that prevents a method from being executed multiple times within a specified delay.
+ *
+ * @param {number} [delay=500] - The delay threshold in milliseconds.
+ * @returns {Function} - The decorated method descriptor.
+ */
+export declare function AvoidDoubleExecution(delay?: number): (_target: any, _key: string, descriptor: PropertyDescriptor) => PropertyDescriptor;

package/{lib → dist/lib}/table/event-listener.if.d.ts

@@ -2,12 +2,14 @@ import { GeMouseEvent } from "./data/common/event/ge-mouse-event";
 import { GeModelChangeEvent } from "./data/common/event/ge-model-change-event";
 import { SelectionModelIf } from './selection/selection-model.if';
 import { FocusModelIf } from './focus/focus-model.if';
+import { EventFocusChangedListenerIf } from './focus/event-focus-changed-listener.if';
+import { EventSelectionChangedListenerIf } from './selection/event-selection-changed-listener.if';
 /**
  * Interface representing an event listener.
  *
  * @interface
  */
-export interface EventListenerIf {
+export interface EventListenerIf extends EventFocusChangedListenerIf, EventSelectionChangedListenerIf {
     onContextmenu(evt: GeMouseEvent): void;
     onMouseMoved(evt: GeMouseEvent): void;
     onMouseDraggingEnd(evt: GeMouseEvent): void;

package/dist/lib/table/focus/event-focus-changed-listener.if.d.ts

@@ -0,0 +1,4 @@
+import { FocusModelIf } from './focus-model.if';
+export interface EventFocusChangedListenerIf {
+    onFocusChanged(model: FocusModelIf): void;
+}

package/{lib → dist/lib}/table/focus/focus-model.d.ts

@@ -1,11 +1,17 @@
 import { FocusType } from "./focus.type";
 import { FocusModelIf } from "./focus-model.if";
+import { EventFocusChangedListenerIf } from './event-focus-changed-listener.if';
 export declare class FocusModel implements FocusModelIf {
     selectionType: FocusType;
     protected rowIndex: number;
     protected columnIndex: number;
     protected changed: boolean;
+    private listenerArr;
     constructor(selectionType?: FocusType);
+    getEventFocusChangedListeners(): EventFocusChangedListenerIf[];
+    addEventFocusChangedListener(listener: EventFocusChangedListenerIf): void;
+    removeEventFocusChangedListener(listener: EventFocusChangedListenerIf): void;
+    fireChangeEvent(): void;
     clearChanged(): void;
     hasChanged(): boolean;
     clear(): void;

package/dist/lib/table/focus/focus-model.if.d.ts

@@ -0,0 +1,12 @@
+import { EventFocusChangedListenerIf } from './event-focus-changed-listener.if';
+export interface FocusModelIf {
+    getEventFocusChangedListeners(): EventFocusChangedListenerIf[];
+    addEventFocusChangedListener(listener: EventFocusChangedListenerIf): void;
+    removeEventFocusChangedListener(listener: EventFocusChangedListenerIf): void;
+    clear(): void;
+    setFocus(rowIndex: number, columnIndex: number): void;
+    hasFocus(rowIndex: number, columnIndex: number): boolean;
+    getFocus(): [number, number];
+    hasChanged(): boolean;
+    clearChanged(): void;
+}

package/dist/lib/table/renderer/positive-and-negative-number-renderer.d.ts

@@ -0,0 +1,8 @@
+import { CellRendererIf } from "./cell-render.if";
+import { AreaIdent } from "../data/tablemodel/area-ident.type";
+import { AreaModelIf } from "../data/tablemodel/areamodel/area-model.if";
+import { DomServiceIf } from "../service/dom-service.if";
+import { RendererCleanupFnType } from "./renderer-cleanup-fn.type";
+export declare class PositiveAndNegativeNumberRenderer implements CellRendererIf {
+    render(cellDiv: HTMLDivElement, rowIndex: number, columnIndex: number, areaIdent: AreaIdent, _areaModel: AreaModelIf, cellValue: any, domService: DomServiceIf): RendererCleanupFnType | undefined;
+}

package/dist/lib/table/selection/event-selection-changed-listener.if.d.ts

@@ -0,0 +1,4 @@
+import { SelectionModelIf } from './selection-model.if';
+export interface EventSelectionChangedListenerIf {
+    onSelectionChanged(model: SelectionModelIf): void;
+}

package/{lib → dist/lib}/table/selection/multi-rows-selection-model.d.ts

@@ -31,6 +31,15 @@ export declare class MultiRowsSelectionModel<T> extends SelectionModel {
      * Toggles the selection of items based on current selection state.
      */
     toggleSelection(): void;
+    /**
+     * Toggles the selection of filtered rows.
+     * If all rows are currently selected, clears the selection.
+     * If no rows are currently selected, selects all filtered rows.
+     * Otherwise, toggles the selection of all filtered rows.
+     *
+     * @return {void}
+     */
+    toggleFilteredRowsSelection(): void;
     /**
      * Toggles the selection state of a row.
      *

package/{lib → dist/lib}/table/selection/selection-model.d.ts

@@ -1,13 +1,20 @@
 import { CellRange } from "../data/common/cell-range";
 import { ExtendedSelectionType, SelectionMode } from './selection.type';
 import { SelectionModelIf } from "./selection-model.if";
+import { EventSelectionChangedListenerIf } from './event-selection-changed-listener.if';
 export declare class SelectionModel implements SelectionModelIf {
     selectionType: ExtendedSelectionType;
     selectionMode: SelectionMode;
     protected ranges: CellRange[];
     protected negativeRanges: CellRange[];
     protected allSelected: boolean;
+    protected silent: boolean;
+    private listenerArr;
     constructor(selectionType?: ExtendedSelectionType, selectionMode?: SelectionMode);
+    getEventSelectionChangedListeners(): EventSelectionChangedListenerIf[];
+    addEventSelectionChangedListener(listener: EventSelectionChangedListenerIf): void;
+    removeEventSelectionChangedListener(listener: EventSelectionChangedListenerIf): void;
+    fireChangeEvent(): void;
     firstClick(rowIndex: number, columnIndex: number): void;
     getSelectionCount(rowIndex: number, columnIndex: number): number;
     isInNegativeRange(rowIndex: number, columnIndex: number): boolean;

package/{lib → dist/lib}/table/selection/selection-model.if.d.ts

@@ -1,5 +1,9 @@
 import { CellRange } from "../data/common/cell-range";
+import { EventSelectionChangedListenerIf } from './event-selection-changed-listener.if';
 export interface SelectionModelIf {
+    getEventSelectionChangedListeners(): EventSelectionChangedListenerIf[];
+    addEventSelectionChangedListener(listener: EventSelectionChangedListenerIf): void;
+    removeEventSelectionChangedListener(listener: EventSelectionChangedListenerIf): void;
     /**
      * Toggles the selection state of a point at the specified row and column in a grid.
      *

package/{lib → dist/lib}/table/table-scope.d.ts

@@ -21,6 +21,8 @@ import { CopyServiceIf } from './service/copy-service.if';
 import { MouseTargetData } from './data/event/mouse-target-data';
 import { SelectionModelIf } from './selection/selection-model.if';
 import { FocusModelIf } from './focus/focus-model.if';
+import { EventFocusChangedListenerIf } from './focus/event-focus-changed-listener.if';
+import { EventSelectionChangedListenerIf } from './selection/event-selection-changed-listener.if';
 /**
  * The TableScope class extends the RenderScope class and provides functionality for rendering and interacting with a table.
  *
@@ -47,8 +49,8 @@ import { FocusModelIf } from './focus/focus-model.if';
  * Methods: Please refer to the documentation of the superclass RenderScope for the inherited methods.
  * The TableScope class introduces additional methods not listed here. Please refer to the source code for further details.
  */
-export declare class TableScope extends RenderScope implements OnActionTriggeredIf {
-    readonly eventListener: EventListenerIf;
+export declare class TableScope extends RenderScope implements OnActionTriggeredIf, EventFocusChangedListenerIf, EventSelectionChangedListenerIf {
+    protected readonly eventListener: EventListenerIf;
     readonly copyService: CopyServiceIf;
     licenseManager: LicenseManager;
     mouseHandler: MouseHandler;
@@ -177,6 +179,8 @@ export declare class TableScope extends RenderScope implements OnActionTriggered
     onMouseClicked(evt: GeMouseEvent, previousEvt: GeMouseEvent | undefined): boolean;
     debounceRepaint(): void;
     publishGeMouseEvent(evt: GeMouseEvent): void;
+    onFocusChanged(sm: FocusModelIf): void;
+    onSelectionChanged(sm: SelectionModelIf): void;
     /**
      * Updates the table (repaint) when an external filter is changed.
      *

package/dist/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@guiexpert/table",
+  "version": "1.1.19",
+  "private": false,
+
+  "type": "module",
+  "main": "./index.js",
+  "types": "./index.d.ts",
+  "lib": {
+    "entryFile": "src/index.ts"
+  },
+  "scripts": {
+    "i": "pnpm i",
+
+    "build": "vite build && npm run concat-css:main && npm run concat-css:dist",
+    "concat-css:main": "cat css/table*.css > css/main.css",
+    "concat-css:dist": "cat css/table*.css > dist/css/main.css",
+
+    "typedoc:json": "npx typedoc --json ../../apps/table-website/src/assets/json/doctype.json src/index.ts",
+    "typedoc:docs-html": "npx typedoc --out ../../apps/table-website/src/assets/docs src/index.ts",
+    "typedoc:docs-html-custom-css": "npx typedoc --customCss ./doc.css --out ../../apps/table-website/src/assets/docs src/index.ts",
+    "typedoc:docs-md": "npx typedoc --plugin typedoc-plugin-markdown --out ../../apps/table-website/src/assets/docsmd src/index.ts",
+    "npm-pub:table": "npm publish --access public"
+  },
+  "exports": {
+    ".": {
+      "import": "./index.js",
+      "require": "./index.cjs"
+    }
+  },
+  "dependencies": {
+    "tslib": "^2.3.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.11.17",
+    "vite": "^5.1.1",
+    "vite-plugin-dts": "^3.7.2",
+    "vite-plugin-eslint": "^1.8.1",
+    "vite-plugin-static-copy": "^0.17.0",
+    "vite-tsconfig-paths": "^4.2.1",
+    "vite-plugin-babel": "^1.2.0",
+    "ts-node": "10.9.1",
+    "tsconfig": "^7.0.0",
+    "typedoc": "0.25.3",
+    "typedoc-plugin-rename-defaults": "^0.7.0",
+    "typedoc-plugin-markdown": "3.17.1",
+    "typescript": "5.2.2"
+  }
+}
+
+