cabloy 5.1.169 → 5.1.170

package/zova/src/suite-vendor/a-cabloy/modules/a-layoutprofile/src/apiSchema/layoutprofile.ts

@@ -0,0 +1,25 @@
+import type { IApiSchemaOptions } from 'zova-module-a-api';
+
+import { BeanBase } from 'zova';
+import { ApiSchema } from 'zova-module-a-api';
+
+import {
+  ApiApiLayoutprofileloadPath,
+  ApiApiLayoutprofilesavePath,
+  ApiApiLayoutprofileresetPath,
+} from '../api/layoutprofile.js';
+
+@ApiSchema()
+export class ApiSchemaLayoutprofile extends BeanBase {
+  load(options?: IApiSchemaOptions) {
+    return this.$sdk.createApiSchemas(ApiApiLayoutprofileloadPath, 'get', options);
+  }
+
+  save(options?: IApiSchemaOptions) {
+    return this.$sdk.createApiSchemas(ApiApiLayoutprofilesavePath, 'post', options);
+  }
+
+  reset(options?: IApiSchemaOptions) {
+    return this.$sdk.createApiSchemas(ApiApiLayoutprofileresetPath, 'delete', options);
+  }
+}

package/zova/src/suite-vendor/a-cabloy/modules/a-layoutprofile/src/index.ts

@@ -0,0 +1 @@
+export * from './.metadata/index.js';

package/zova/src/suite-vendor/a-cabloy/modules/a-layoutprofile/src/model/layoutprofile.ts

@@ -0,0 +1,76 @@
+import type { IDecoratorModelOptions } from 'zova-module-a-model';
+
+import { BeanModelBase, Model } from 'zova-module-a-model';
+
+import type {
+  ApiApiLayoutprofileloadResponseBody,
+  ApiApiLayoutprofileresetResponseBody,
+  ApiApiLayoutprofilesaveRequestBody,
+  ApiApiLayoutprofilesaveResponseBody,
+} from '../api/layoutprofile.js';
+
+export interface IModelOptionsLayoutProfile extends IDecoratorModelOptions {
+  enableSelector: true;
+}
+
+@Model<IModelOptionsLayoutProfile>({
+  enableSelector: true,
+})
+export class ModelLayoutProfile extends BeanModelBase {
+  layoutKey: string;
+
+  protected async __init__(layoutKey: string) {
+    if (!layoutKey) throw new Error('layout key not specified');
+    await super.__init__(layoutKey);
+    this.layoutKey = layoutKey;
+  }
+
+  load() {
+    if (this.$ssr.cookieDisabledOnServer || !this.$passport.isAuthenticated) return;
+    if (process.env.CLIENT && this.$ssr.profile === 'public' && this.$ssr.isRuntimeSsrPreHydration)
+      return;
+    return this.$useStateData<ApiApiLayoutprofileloadResponseBody>({
+      queryKey: ['load'],
+      queryFn: async () => {
+        return await this.scope.api.layoutprofile.load({
+          query: { layoutKey: this.layoutKey },
+        });
+      },
+      meta: {
+        disableErrorEffect: true,
+      },
+    });
+  }
+
+  save() {
+    return this.$useMutationData<
+      ApiApiLayoutprofilesaveResponseBody,
+      ApiApiLayoutprofilesaveRequestBody['profile']
+    >({
+      mutationKey: ['save'],
+      mutationFn: async profile => {
+        return await this.scope.api.layoutprofile.save({
+          layoutKey: this.layoutKey,
+          profile,
+        });
+      },
+      onSuccess: profile => {
+        this.$setQueryData<ApiApiLayoutprofilesaveResponseBody>(['load'], profile);
+      },
+    });
+  }
+
+  reset() {
+    return this.$useMutationData<ApiApiLayoutprofileresetResponseBody>({
+      mutationKey: ['reset'],
+      mutationFn: async () => {
+        return await this.scope.api.layoutprofile.reset({
+          query: { layoutKey: this.layoutKey },
+        });
+      },
+      onSuccess: async () => {
+        this.$setQueryData<ApiApiLayoutprofileloadResponseBody>(['load'], undefined);
+      },
+    });
+  }
+}

package/zova/src/suite-vendor/a-cabloy/modules/a-layoutprofile/tsconfig.build.json

@@ -0,0 +1,13 @@
+{
+  "extends": "../../tsconfig.base",
+  "compilerOptions": {
+    "rootDir": "src",
+    "outDir": "dist",
+    "declaration": true,
+    "declarationMap": true,
+    "emitDeclarationOnly": true,
+    "allowImportingTsExtensions": true,
+    "noEmit": false
+  },
+  "include": ["src", "src/.metadata/**/*"]
+}

package/zova/src/suite-vendor/a-cabloy/modules/a-layoutprofile/tsconfig.json

@@ -0,0 +1,5 @@
+{
+  "extends": "../../tsconfig.base",
+  "compilerOptions": {},
+  "include": ["src", "src/.metadata/**/*"]
+}

package/zova/src/suite-vendor/a-cabloy/package.json

@@ -1,12 +1,13 @@
 {
   "name": "zova-suite-a-cabloy",
-  "version": "5.1.55",
+  "version": "5.1.56",
   "gitHead": "4dece229b6d3f4735930e833afcb4b95ec51bf86",
   "description": "",
   "author": "",
   "files": [],
   "type": "module",
   "dependencies": {
+    "zova-module-a-layoutprofile": "^5.0.2",
     "zova-module-a-rbac": "^5.0.1",
     "zova-module-rest-resource": "^5.1.54"
   },

package/zova/src/suite-vendor/a-zova/modules/a-openapi/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zova-module-a-openapi",
-  "version": "5.1.53",
+  "version": "5.1.54",
   "gitHead": "09d901d17140a80ee0764211b441cda72fd94663",
   "description": "",
   "keywords": [

package/zova/src/suite-vendor/a-zova/modules/a-openapi/src/types/resource/tableActionBulk.ts

@@ -20,9 +20,12 @@ export interface IResourceTableSelectionPayload<TData extends {} = Record<string
 }
 
 /** Declarative bulk-action metadata authored by a resource schema. */
+export type TypeResourceTableActionBulkPlacement = 'start' | 'end';
+
 export interface IResourceTableActionBulkOptionsBase {
   class?: any;
   style?: types.NestedCSSProperties;
+  placement?: TypeResourceTableActionBulkPlacement;
   resource?: string;
   permission?: IPermissionHintTableActionBulk;
   requiresSelection?: boolean;

package/zova/src/suite-vendor/a-zova/modules/a-ssr/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zova-module-a-ssr",
-  "version": "5.1.38",
+  "version": "5.1.39",
   "gitHead": "09d901d17140a80ee0764211b441cda72fd94663",
   "description": "",
   "keywords": [

package/zova/src/suite-vendor/a-zova/modules/a-ssr/src/lib/bodyReadyObserver.ts

@@ -1,19 +1,21 @@
 export function getBodyReadyObserverScript() {
   return `<script id="ssr-body-ready-observer">
         window.ssr_bodyReadyObserverClear=()=>{
-          if(window.ssr_bodyReadyObserver){
-            window.ssr_body_ready_condition=undefined;
-            window.ssr_body_ready_callback=undefined;
-            window.ssr_bodyReadyObserver.disconnect();
-            window.ssr_bodyReadyObserver=undefined;
-            document.body.style.display='block';
-            document.querySelector('#ssr-body-ready-observer').remove();
-          }
+          window.ssr_body_ready_condition=undefined;
+          window.ssr_body_ready_callback=undefined;
+          window.ssr_bodyReadyObserver?.disconnect();
+          window.ssr_bodyReadyObserver=undefined;
+          document.body.style.display='block';
+          document.querySelector('#ssr-body-ready-observer')?.remove();
         };
         window.ssr_bodyReadyObserver = new MutationObserver(() => {
-          if(window.ssr_body_ready_condition && window.ssr_body_ready_condition()){
-            window.ssr_body_ready_callback();
-            window.ssr_bodyReadyObserverClear();
+          const __targets=window.ssr_body_ready_condition?.();
+          if(__targets){
+            try{
+              window.ssr_body_ready_callback?.(__targets);
+            }finally{
+              window.ssr_bodyReadyObserverClear();
+            }
           }
         });
         window.ssr_bodyReadyObserver.observe(document.body, {

package/zova/src/suite-vendor/a-zova/modules/a-table/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zova-module-a-table",
-  "version": "5.1.42",
+  "version": "5.1.43",
   "gitHead": "09d901d17140a80ee0764211b441cda72fd94663",
   "description": "",
   "keywords": [

package/zova/src/suite-vendor/a-zova/modules/a-table/src/component/table/controller.tsx

@@ -45,13 +45,16 @@ import type {
   ITableScope,
   TypeTableCellRender,
 } from '../../types/tableColumn.js';
+import type { ITableLayout } from '../../types/tableLayout.js';
 
 import { BeanControllerTableBase } from '../../lib/beanControllerTableBase.js';
 import { TableColumnIdSelection } from '../../types/table.js';
 import { ITableCellRenderColumnOptions } from '../../types/tableColumn.js';
+import { reconcileTableLayout } from '../../types/tableLayout.js';
 
 export interface ControllerTableProps<TData extends {} = {}> {
   data?: TData[];
+  layout?: ITableLayout;
   schema?: SchemaObject;
   schemaOrder?: SchemaObject;
   sorting?: SortingState;
@@ -102,6 +105,13 @@ export class ControllerTable<TData extends {} = {}> extends BeanControllerTableB
         await this.refreshMeta();
       },
     );
+    this.$watch(
+      () => this.$props.layout,
+      async (newValue, oldValue) => {
+        if (deepEqual(newValue, oldValue)) return;
+        await this.refreshMeta();
+      },
+    );
     // table
     this._createTable();
   }
@@ -122,6 +132,14 @@ export class ControllerTable<TData extends {} = {}> extends BeanControllerTableB
     return this.$props.rowSelection ?? {};
   }
 
+  public get layout(): ITableLayout {
+    return reconcileTableLayout(this.layoutProperties, this.$props.layout);
+  }
+
+  public get layoutProperties(): readonly ISchemaObjectExtensionField[] {
+    return this.tableMeta?.properties ?? [];
+  }
+
   public async refreshMeta() {
     this.tableMeta = await this._createTableMeta();
     this.columns = await this._createColumns();
@@ -148,6 +166,15 @@ export class ControllerTable<TData extends {} = {}> extends BeanControllerTableB
         get rowSelection() {
           return self.rowSelection;
         },
+        get columnVisibility() {
+          return self._getColumnVisibility();
+        },
+        get columnOrder() {
+          return self._getColumnOrder();
+        },
+        get columnSizing() {
+          return self._getColumnSizing();
+        },
       },
       onSortingChange: updater => {
         const sorting = functionalUpdate(updater, self.sorting).slice(0, 1);
@@ -235,10 +262,15 @@ export class ControllerTable<TData extends {} = {}> extends BeanControllerTableB
             return property?.title || key;
           },
           cell: props => tableMeta.renders[key](props),
-          size: property.rest?.width,
+          size: this._getLayoutWidth(key),
           enableSorting: property.rest?.enableSorting === true && this._isOrderable(property),
           sortDescFirst: property.rest?.sortDescFirst === true,
-          meta: { rest: property.rest },
+          meta: {
+            rest: {
+              ...property.rest,
+              width: this._getLayoutWidth(key),
+            },
+          },
         }),
       );
     }
@@ -262,6 +294,36 @@ export class ControllerTable<TData extends {} = {}> extends BeanControllerTableB
     return typeof enableRowSelection === 'function' ? enableRowSelection(row) : true;
   }
 
+  private _getLayoutColumn(key: string) {
+    return this.layout.columns.find(column => column.key === key);
+  }
+
+  private _getLayoutWidth(key: string) {
+    const width = this._getLayoutColumn(key)?.width;
+    return typeof width === 'number' ? width : undefined;
+  }
+
+  private _getColumnVisibility() {
+    return Object.fromEntries(
+      this.layout.columns
+        .filter(column => column.key !== TableColumnIdSelection)
+        .map(column => [column.key, column.visible]),
+    );
+  }
+
+  private _getColumnOrder() {
+    const keys = this.layout.columns.map(column => column.key);
+    return this.$props.enableRowSelection ? [TableColumnIdSelection, ...keys] : keys;
+  }
+
+  private _getColumnSizing() {
+    return Object.fromEntries(
+      this.layout.columns
+        .filter(column => typeof column.width === 'number')
+        .map(column => [column.key, column.width as number]),
+    );
+  }
+
   private _getColumnPinning() {
     const left: string[] = this.$props.enableRowSelection ? [TableColumnIdSelection] : [];
     const right: string[] = [];

package/zova/src/suite-vendor/a-zova/modules/a-table/src/component/table/render.tsx

@@ -11,10 +11,9 @@ export class RenderTable extends BeanRenderBase {
   private _getColumnStyle(column: any): CSSProperties {
     const rest = (column.columnDef.meta as any)?.rest;
     const fixed = column.getIsPinned();
-    const width = rest?.width ? `${rest.width}px` : undefined;
+    const width = column.getSize();
     return {
-      width,
-      minWidth: width,
+      ...(typeof rest?.width === 'number' ? { width: `${width}px`, minWidth: `${width}px` } : {}),
       textAlign: rest?.align,
       position: fixed ? ('sticky' as const) : undefined,
       left: fixed === 'left' ? `${column.getStart('left')}px` : undefined,

package/zova/src/suite-vendor/a-zova/modules/a-table/src/lib/beanControllerTableBase.ts

@@ -1,15 +1,25 @@
 import type { Table } from '@tanstack/table-core';
 import type { TableOptionsWithReactiveData } from '@tanstack/vue-table';
+import type { ISchemaObjectExtensionField } from 'zova-module-a-openapi';
 
 import { useVueTable } from '@tanstack/vue-table';
 import { markRaw } from 'vue';
 import { BeanControllerBase } from 'zova';
 
 import { TypeTable } from '../types/table.js';
+import { ITableLayout } from '../types/tableLayout.js';
 
 export class BeanControllerTableBase<TData extends {} = {}> extends BeanControllerBase {
   table: TypeTable<TData>;
 
+  public get layout(): ITableLayout {
+    throw new Error('should implement layout');
+  }
+
+  public get layoutProperties(): readonly ISchemaObjectExtensionField[] {
+    throw new Error('should implement layoutProperties');
+  }
+
   public $useTable(initialOptions: TableOptionsWithReactiveData<TData>): Table<TData> {
     return this.ctx.util.instanceScope(() => {
       return markRaw(useVueTable(initialOptions));

package/zova/src/suite-vendor/a-zova/modules/a-table/src/types/index.ts

@@ -1,3 +1,4 @@
 export * from './table.js';
 export * from './tableCell.js';
 export * from './tableColumn.js';
+export * from './tableLayout.js';

package/zova/src/suite-vendor/a-zova/modules/a-table/src/types/tableLayout.ts

@@ -0,0 +1,101 @@
+import type { ISchemaObjectExtensionField } from 'zova-module-a-openapi';
+
+import { TableColumnIdSelection } from './table.js';
+
+export type TypeTableLayoutWidth = number | 'auto';
+
+export interface ITableLayoutColumn {
+  key: string;
+  visible: boolean;
+  width: TypeTableLayoutWidth;
+}
+
+export interface ITableLayout {
+  version: 1;
+  schemaFingerprint?: string;
+  columns: ITableLayoutColumn[];
+}
+
+export interface ITableLayoutProfileLike {
+  version?: unknown;
+  schemaFingerprint?: unknown;
+  columns?: unknown;
+}
+
+function isWidth(value: unknown): value is TypeTableLayoutWidth {
+  return (
+    value === 'auto' ||
+    (typeof value === 'number' && Number.isInteger(value) && value >= 1 && value <= 2000)
+  );
+}
+
+/**
+ * Reconciles a persisted layout with the currently eligible schema columns.
+ * Schema visibility and fixed regions always remain authoritative.
+ */
+export function reconcileTableLayout(
+  properties: readonly ISchemaObjectExtensionField[],
+  profile?: ITableLayoutProfileLike | ITableLayout,
+): ITableLayout {
+  const entries = new Map<string, ITableLayoutColumn>();
+  const profileColumns = Array.isArray(profile?.columns) ? profile.columns : [];
+  for (const item of profileColumns) {
+    if (!item || typeof item !== 'object') continue;
+    const column = item as Record<string, unknown>;
+    const key = typeof column.key === 'string' ? column.key.trim() : '';
+    if (!key || entries.has(key)) continue;
+    if (typeof column.visible !== 'boolean' || !isWidth(column.width)) continue;
+    entries.set(key, { key, visible: column.visible, width: column.width });
+  }
+
+  const eligible = properties.filter(
+    property =>
+      typeof property.key === 'string' && property.key && property.key !== TableColumnIdSelection,
+  );
+  const schemaKeys = new Set(eligible.map(property => property.key!));
+  const regions = new Map<'left' | 'center' | 'right', ISchemaObjectExtensionField[]>();
+  regions.set('left', []);
+  regions.set('center', []);
+  regions.set('right', []);
+  for (const property of eligible) {
+    const fixed = property.rest?.fixed;
+    regions.get(fixed === 'left' ? 'left' : fixed === 'right' ? 'right' : 'center')!.push(property);
+  }
+
+  const result: ITableLayoutColumn[] = [];
+  for (const region of ['left', 'center', 'right'] as const) {
+    const regionProperties = regions.get(region)!;
+    const regionKeys = new Set(regionProperties.map(property => property.key!));
+    const ordered = profileColumns
+      .map(item =>
+        item && typeof item === 'object' ? (item as Record<string, unknown>) : undefined,
+      )
+      .filter(item => {
+        const key = typeof item?.key === 'string' ? item.key.trim() : '';
+        return !!key && regionKeys.has(key) && schemaKeys.has(key) && entries.get(key)?.key === key;
+      })
+      .map(item => item!.key as string);
+    const seen = new Set<string>();
+    for (const key of [...ordered, ...regionProperties.map(property => property.key!)]) {
+      if (seen.has(key)) continue;
+      seen.add(key);
+      const property = regionProperties.find(item => item.key === key)!;
+      const entry = entries.get(key);
+      const schemaWidth = property.rest?.width;
+      result.push({
+        key,
+        visible: entry?.visible ?? true,
+        width:
+          entry?.width ??
+          (typeof schemaWidth === 'number' && schemaWidth > 0 ? schemaWidth : 'auto'),
+      });
+    }
+  }
+  return {
+    version: 1,
+    ...(typeof profile?.schemaFingerprint === 'string'
+      ? { schemaFingerprint: profile.schemaFingerprint }
+      : {}),
+    columns: result,
+  };
+}

package/zova/src/suite-vendor/a-zova/modules/a-table/test/lib/tableLayout.test.ts

@@ -0,0 +1,112 @@
+import type { ISchemaObjectExtensionField } from 'zova-module-a-openapi';
+
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import { TableColumnIdSelection } from '../../src/types/table.js';
+import { reconcileTableLayout } from '../../src/types/tableLayout.js';
+
+function createProperties(...properties: ISchemaObjectExtensionField[]) {
+  return properties;
+}
+
+test('table layout drops stale and malformed profile columns while preserving schema defaults', () => {
+  const layout = reconcileTableLayout(
+    createProperties(
+      { key: 'id', type: 'number', rest: { width: 60, fixed: 'left' } },
+      { key: 'name', type: 'string' },
+      { key: 'level', type: 'string', rest: { width: 120 } },
+      { key: 'operations', type: 'string', rest: { width: 360, fixed: 'right' } },
+    ),
+    {
+      version: 1,
+      schemaFingerprint: 'student-v1',
+      columns: [
+        { key: 'name', visible: false, width: 480 },
+        { key: 'obsolete', visible: true, width: 80 },
+        { key: 'level', visible: true, width: 0 },
+        { key: 'operations', visible: true, width: 'auto' },
+        { key: '', visible: false, width: 90 },
+      ],
+    },
+  );
+
+  assert.deepEqual(layout, {
+    version: 1,
+    schemaFingerprint: 'student-v1',
+    columns: [
+      { key: 'id', visible: true, width: 60 },
+      { key: 'name', visible: false, width: 480 },
+      { key: 'level', visible: true, width: 120 },
+      { key: 'operations', visible: true, width: 'auto' },
+    ],
+  });
+});
+
+test('table layout retains the first valid duplicate and appends new schema fields', () => {
+  const layout = reconcileTableLayout(
+    createProperties(
+      { key: 'name', type: 'string' },
+      { key: 'level', type: 'string' },
+      { key: 'createdAt', type: 'string', rest: { width: 180 } },
+    ),
+    {
+      columns: [
+        { key: 'level', visible: false, width: 240 },
+        { key: 'name', visible: true, width: 'auto' },
+        { key: 'level', visible: true, width: 300 },
+      ],
+    },
+  );
+
+  assert.deepEqual(layout.columns, [
+    { key: 'level', visible: false, width: 240 },
+    { key: 'name', visible: true, width: 'auto' },
+    { key: 'createdAt', visible: true, width: 180 },
+  ]);
+});
+
+test('table layout permits ordering only within schema fixed regions', () => {
+  const layout = reconcileTableLayout(
+    createProperties(
+      { key: 'leftFirst', type: 'string', rest: { fixed: 'left' } },
+      { key: 'leftSecond', type: 'string', rest: { fixed: 'left' } },
+      { key: 'centerFirst', type: 'string' },
+      { key: 'centerSecond', type: 'string' },
+      { key: 'rightFirst', type: 'string', rest: { fixed: 'right' } },
+      { key: 'rightSecond', type: 'string', rest: { fixed: 'right' } },
+    ),
+    {
+      columns: [
+        { key: 'rightSecond', visible: true, width: 'auto' },
+        { key: 'centerSecond', visible: true, width: 'auto' },
+        { key: 'leftSecond', visible: true, width: 'auto' },
+        { key: 'rightFirst', visible: true, width: 'auto' },
+        { key: 'centerFirst', visible: true, width: 'auto' },
+        { key: 'leftFirst', visible: true, width: 'auto' },
+      ],
+    },
+  );
+
+  assert.deepEqual(
+    layout.columns.map(column => column.key),
+    ['leftSecond', 'leftFirst', 'centerSecond', 'centerFirst', 'rightSecond', 'rightFirst'],
+  );
+});
+
+test('table layout excludes synthetic selection state from persistence', () => {
+  const layout = reconcileTableLayout(
+    createProperties(
+      { key: TableColumnIdSelection, type: 'boolean' },
+      { key: 'name', type: 'string' },
+    ),
+    {
+      columns: [
+        { key: TableColumnIdSelection, visible: false, width: 40 },
+        { key: 'name', visible: true, width: 'auto' },
+      ],
+    },
+  );
+
+  assert.deepEqual(layout.columns, [{ key: 'name', visible: true, width: 'auto' }]);
+});

package/zova/src/suite-vendor/a-zova/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zova-suite-a-zova",
-  "version": "5.1.160",
+  "version": "5.1.161",
   "gitHead": "2c5c19284bab738e492856189acb6fad74b8a7b7",
   "description": "zova",
   "license": "MIT",
@@ -22,15 +22,15 @@
     "zova-module-a-logger": "^5.1.28",
     "zova-module-a-meta": "^5.1.22",
     "zova-module-a-model": "^5.1.36",
-    "zova-module-a-openapi": "^5.1.53",
+    "zova-module-a-openapi": "^5.1.54",
     "zova-module-a-router": "^5.1.37",
     "zova-module-a-routerstack": "^5.1.29",
     "zova-module-a-routertabs": "^5.1.34",
-    "zova-module-a-ssr": "^5.1.38",
+    "zova-module-a-ssr": "^5.1.39",
     "zova-module-a-ssrhmr": "^5.1.23",
     "zova-module-a-ssrserver": "^5.1.26",
     "zova-module-a-style": "^5.1.35",
-    "zova-module-a-table": "^5.1.42",
+    "zova-module-a-table": "^5.1.43",
     "zova-module-a-zod": "^5.1.37",
     "zova-module-a-zova": "^5.1.104"
   },