cabloy 5.1.246 → 5.1.247

package/zova/src/suite/cabloy-basic/modules/basic-table/src/.metadata/index.ts

@@ -4,6 +4,7 @@ export * from '../component/actionColumnConfig/controller.tsx';
 export * from '../component/actionCreate/controller.tsx';
 export * from '../component/actionDeleteBulk/controller.tsx';
 export * from '../component/actionRefresh/controller.tsx';
+export * from '../component/rowOperations/controller.tsx';
 export * from '../component/table/controller.tsx';
 
 import 'zova';
@@ -33,6 +34,11 @@ declare module 'zova-module-basic-table' {
           get scope(): ScopeModuleBasicTable;
         }
 
+        export interface ControllerRowOperations {
+          /** @internal */
+          get scope(): ScopeModuleBasicTable;
+        }
+
         export interface ControllerTable {
           /** @internal */
           get scope(): ScopeModuleBasicTable;
@@ -44,6 +50,7 @@ import type { ControllerActionColumnConfig } from '../component/actionColumnConf
 import type { ControllerActionCreate } from '../component/actionCreate/controller.tsx';
 import type { ControllerActionDeleteBulk } from '../component/actionDeleteBulk/controller.tsx';
 import type { ControllerActionRefresh } from '../component/actionRefresh/controller.tsx';
+import type { ControllerRowOperations } from '../component/rowOperations/controller.tsx';
 import type { ControllerTable } from '../component/table/controller.tsx';
 import 'zova';
 declare module 'zova' {
@@ -52,6 +59,7 @@ declare module 'zova' {
 'basic-table.controller.actionCreate': ControllerActionCreate;
 'basic-table.controller.actionDeleteBulk': ControllerActionDeleteBulk;
 'basic-table.controller.actionRefresh': ControllerActionRefresh;
+'basic-table.controller.rowOperations': ControllerRowOperations;
 'basic-table.controller.table': ControllerTable;
   }
 }
@@ -66,6 +74,8 @@ export * from './component/actionDeleteBulk.ts';
 import { ZActionDeleteBulk } from './component/actionDeleteBulk.ts';
 export * from './component/actionRefresh.ts';
 import { ZActionRefresh } from './component/actionRefresh.ts';
+export * from './component/rowOperations.ts';
+import { ZRowOperations } from './component/rowOperations.ts';
 export * from './component/table.ts';
 import { ZTable } from './component/table.ts';
 export const components = {
@@ -73,6 +83,7 @@ export const components = {
 'actionCreate': ZActionCreate,
 'actionDeleteBulk': ZActionDeleteBulk,
 'actionRefresh': ZActionRefresh,
+'rowOperations': ZRowOperations,
 'table': ZTable,
 };
 import 'zova';
@@ -82,6 +93,7 @@ export interface IComponentRecord {
 'basic-table:actionCreate': ControllerActionCreate;
 'basic-table:actionDeleteBulk': ControllerActionDeleteBulk;
 'basic-table:actionRefresh': ControllerActionRefresh;
+'basic-table:rowOperations': ControllerRowOperations;
 'basic-table:table': ControllerTable;
 }
 export interface IZovaComponentRecord {
@@ -89,6 +101,7 @@ export interface IZovaComponentRecord {
 'basic-table:actionCreate': typeof ZActionCreate;
 'basic-table:actionDeleteBulk': typeof ZActionDeleteBulk;
 'basic-table:actionRefresh': typeof ZActionRefresh;
+'basic-table:rowOperations': typeof ZRowOperations;
 'basic-table:table': typeof ZTable;
 }
 }

package/zova/src/suite/cabloy-basic/modules/basic-table/src/bean/tableCell.actionDelete.tsx

@@ -16,7 +16,9 @@ declare module 'zova-module-a-openapi' {
   }
 }
 
-export interface ITableCellOptionsActionDelete extends IResourceTableActionRowOptionsBase {}
+export interface ITableCellOptionsActionDelete extends IResourceTableActionRowOptionsBase {
+  showLabel?: boolean;
+}
 
 @TableCell<ITableCellOptionsActionDelete>({
   class: 'btn btn-outline btn-error join-item',
@@ -31,6 +33,7 @@ export class TableCellActionDelete extends BeanBase implements ITableCellRender
     return (
       <ZButton
         class={options.class}
+        aria-label={this.scope.locale.Delete()}
         onPerform={async () => {
           const confirmed = await $host.$performCommand('basic-commands:confirm', {
             text: this.scope.locale.DeleteConfirm(),
@@ -39,7 +42,8 @@ export class TableCellActionDelete extends BeanBase implements ITableCellRender
           await $host.$performCommand('basic-commands:delete', options, renderContext);
         }}
       >
-        <ZIcon name="::delete" width={24}></ZIcon>
+        <ZIcon name="::delete" width={24} aria-hidden="true"></ZIcon>
+        {options.showLabel && this.scope.locale.Delete()}
       </ZButton>
     );
   }

package/zova/src/suite/cabloy-basic/modules/basic-table/src/bean/tableCell.actionOperationsRow.tsx

@@ -1,3 +1,4 @@
+import type { VNode } from 'vue';
 import type {
   IResourceRenderTableActionRowOptionsAction,
   IResourceTableActionRowOptionsBase,
@@ -9,10 +10,12 @@ import type {
   NextTableCellRender,
 } from 'zova-module-a-table';
 
-import { VNode } from 'vue';
+import { Comment, Fragment, isVNode, Text } from 'vue';
 import { BeanBase } from 'zova';
 import { IJsxRenderContextTableColumn, TableCell } from 'zova-module-a-table';
 
+import { ZRowOperations } from '../.metadata/component/rowOperations.ts';
+
 declare module 'zova-module-a-openapi' {
   export interface IResourceTableActionRowRecord {
     'basic-table:actionOperationsRow'?: ITableCellOptionsActionOperationsRow;
@@ -65,10 +68,35 @@ export class TableCellActionOperationsRow extends BeanBase implements ITableCell
       const actionName = action.name;
       const permissionHint = action.options?.permission;
       if (!$host.$passport.checkPermission(permissions, actionName, permissionHint, data)) return;
-      const options2 = Object.assign({ key: index }, action.options);
-      domActions.push($$table.cellRender(action.render!, options2, renderContext));
+      const builtInLabel =
+        action.render === 'basic-table:actionUpdate' ||
+        action.render === 'basic-table:actionDelete';
+      const options2 = Object.assign(
+        { key: index },
+        action.options,
+        builtInLabel ? { showLabel: $$table.compact } : undefined,
+      );
+      const domAction = $$table.cellRender(action.render!, options2, renderContext);
+      if (this._hasContent(domAction)) domActions.push(domAction);
     });
     if (domActions.length === 0) return;
-    return <div class={options.class}>{domActions}</div>;
+    return (
+      <ZRowOperations
+        compact={$$table.compact}
+        class={options.class}
+        slotDefault={() => <>{domActions}</>}
+      />
+    );
+  }
+
+  private _hasContent(value: unknown): boolean {
+    if (value === undefined || value === null || typeof value === 'boolean') return false;
+    if (typeof value === 'string') return value.trim().length > 0;
+    if (Array.isArray(value)) return value.some(item => this._hasContent(item));
+    if (!isVNode(value)) return true;
+    if (value.type === Comment) return false;
+    if (value.type === Text || value.type === Fragment) return this._hasContent(value.children);
+    // Component renderers stay opaque: preserve their VNode and runtime ownership.
+    return true;
   }
 }

package/zova/src/suite/cabloy-basic/modules/basic-table/src/bean/tableCell.actionUpdate.tsx

@@ -16,7 +16,9 @@ declare module 'zova-module-a-openapi' {
   }
 }
 
-export interface ITableCellOptionsActionUpdate extends IResourceTableActionRowOptionsBase {}
+export interface ITableCellOptionsActionUpdate extends IResourceTableActionRowOptionsBase {
+  showLabel?: boolean;
+}
 
 @TableCell<ITableCellOptionsActionUpdate>({
   class: 'btn btn-outline btn-primary join-item',
@@ -31,11 +33,13 @@ export class TableCellActionUpdate extends BeanBase implements ITableCellRender
     return (
       <ZButton
         class={options.class}
+        aria-label={this.scope.locale.Edit()}
         onPerform={async () => {
           await $host.$performCommand('basic-commands:edit', options, renderContext);
         }}
       >
-        <ZIcon name="::draft" width={24}></ZIcon>
+        <ZIcon name="::draft" width={24} aria-hidden="true"></ZIcon>
+        {options.showLabel && this.scope.locale.Edit()}
       </ZButton>
     );
   }

package/zova/src/suite/cabloy-basic/modules/basic-table/src/component/rowOperations/controller.tsx

@@ -0,0 +1,233 @@
+import type { IComponentOptions, ISlot } from 'zova';
+
+import { useId } from 'vue';
+import { BeanControllerBase } from 'zova';
+import { Controller } from 'zova-module-a-bean';
+import { ZIcon } from 'zova-module-a-icon';
+import { ZButton } from 'zova-module-basic-button';
+
+export interface ControllerRowOperationsProps {
+  compact?: boolean;
+  class?: unknown;
+  slotDefault?: ISlot;
+}
+
+@Controller()
+export class ControllerRowOperations extends BeanControllerBase {
+  static $propsDefault = { compact: false };
+  static $componentOptions: IComponentOptions = { inheritAttrs: false };
+
+  private _id: string;
+  private _actionsRef?: HTMLDivElement;
+  private _open = false;
+  private _positionFrame?: number;
+  private _cPopover: string;
+  private _onBeforeToggle: (event: ToggleEvent) => void;
+  private _onViewportChange: (event: Event) => void;
+  private _onKeydown: (event: KeyboardEvent) => void;
+  private _onActionClick: (event: MouseEvent) => void;
+
+  protected async __init__() {
+    this._onActionClick = event => this._handleActionClick(event);
+    this._onBeforeToggle = event => this._handleBeforeToggle(event);
+    this._onKeydown = event => this._handleKeydown(event);
+    this._onViewportChange = event => {
+      if (event.target instanceof Node && this._actionsRef?.contains(event.target)) return;
+      this._close();
+    };
+    this._id = this.$composable(useId);
+    this._cPopover = this.$style({
+      position: 'fixed',
+      inset: 'auto',
+      margin: 0,
+      minWidth: '10rem',
+      maxWidth: 'calc(100vw - 16px)',
+      maxHeight: 'calc(100vh - 16px)',
+      overflowY: 'auto',
+      $nest: {
+        '&:popover-open': {
+          display: 'flex',
+          flexDirection: 'column',
+          alignItems: 'stretch',
+          gap: '0.25rem',
+        },
+        '& > .btn': {
+          justifyContent: 'flex-start',
+        },
+      },
+    });
+    this.$watch(
+      () => this.$props.compact,
+      () => this._close(),
+      { flush: 'sync' },
+    );
+  }
+
+  protected __dispose__() {
+    this._close();
+    this._setActionsRef(undefined);
+  }
+
+  private _setActionsRef(element?: HTMLDivElement) {
+    if (element === this._actionsRef) return;
+    this._actionsRef?.removeEventListener('beforetoggle', this._onBeforeToggle);
+    this._actionsRef?.removeEventListener('click', this._onActionClick, true);
+    this._actionsRef = element;
+    element?.addEventListener('beforetoggle', this._onBeforeToggle);
+    element?.addEventListener('click', this._onActionClick, true);
+  }
+
+  private _handleBeforeToggle(event: ToggleEvent) {
+    if (event.target !== this._actionsRef) return;
+    this._open = event.newState === 'open';
+    if (this._open) {
+      // beforetoggle precedes display; measure in the first frame after native opening.
+      this._actionsRef!.style.visibility = 'hidden';
+      this._positionFrame = window.requestAnimationFrame(() => {
+        this._positionFrame = undefined;
+        if (!this._open) return;
+        this._position();
+        const element = this._actionsRef;
+        element?.style.removeProperty('visibility');
+        const document = element?.ownerDocument;
+        if (
+          document &&
+          (document.activeElement?.id === `${this._id}-trigger` ||
+            document.activeElement === document.body)
+        ) {
+          element
+            ?.querySelector<HTMLElement>('button:not(:disabled), a[href], [tabindex="0"]')
+            ?.focus({ preventScroll: true });
+        }
+        // Opening can follow scroll-into-view with its scroll event still queued.
+        // Arm dismissal only after measuring the settled anchor and revealing the popup.
+        window.addEventListener('scroll', this._onViewportChange, true);
+      });
+      window.addEventListener('resize', this._onViewportChange);
+      this._actionsRef!.ownerDocument.addEventListener('keydown', this._onKeydown);
+    } else {
+      this._clearOpenState();
+    }
+  }
+
+  private _clearOpenState() {
+    this._open = false;
+    if (this._positionFrame !== undefined) {
+      window.cancelAnimationFrame(this._positionFrame);
+      this._positionFrame = undefined;
+    }
+    window.removeEventListener('scroll', this._onViewportChange, true);
+    window.removeEventListener('resize', this._onViewportChange);
+    this._actionsRef?.ownerDocument.removeEventListener('keydown', this._onKeydown);
+    this._actionsRef?.style.removeProperty('visibility');
+    this._actionsRef?.style.removeProperty('left');
+    this._actionsRef?.style.removeProperty('top');
+  }
+
+  private _close() {
+    if (!this._open) return;
+    const element = this._actionsRef;
+    if (element?.isConnected && element.popover === 'auto') element.hidePopover();
+    this._clearOpenState();
+  }
+
+  private _handleActionClick(event: MouseEvent) {
+    if (!this.$props.compact || !this._open || !(event.target instanceof Element)) return;
+    const action = event.target.closest('button, a[href], [role="button"]');
+    if (
+      !action ||
+      !this._actionsRef?.contains(action) ||
+      action.matches(':disabled, [aria-disabled="true"]')
+    ) {
+      return;
+    }
+    this._close();
+  }
+
+  private _handleKeydown(event: KeyboardEvent) {
+    if (event.key !== 'Escape' || event.defaultPrevented || !this._open) return;
+    if (event.target instanceof Element && event.target.closest('dialog[open], [role="dialog"]'))
+      return;
+    const element = this._actionsRef;
+    const document = element?.ownerDocument;
+    const activeElement = document?.activeElement;
+    const trigger = document?.getElementById(`${this._id}-trigger`);
+    if (!document || !activeElement) return;
+    if (activeElement.closest('dialog[open], [role="dialog"]')) return;
+    if (
+      activeElement !== document.body &&
+      activeElement !== trigger &&
+      !element?.contains(activeElement)
+    ) {
+      return;
+    }
+    if (activeElement === document.body && document.querySelector('dialog:modal')) return;
+    // A disabled action can leave focus on body; never claim unrelated focused controls.
+    event.preventDefault();
+    event.stopPropagation();
+    this._close();
+    if (trigger?.isConnected) trigger.focus({ preventScroll: true });
+  }
+
+  private _position() {
+    const element = this._actionsRef;
+    const trigger = element?.ownerDocument.getElementById(`${this._id}-trigger`);
+    if (!element || !trigger) return;
+    const anchor = trigger.getBoundingClientRect();
+    const popup = element.getBoundingClientRect();
+    const viewport = element.ownerDocument.documentElement;
+    const margin = 8;
+    const gap = 4;
+    const left = Math.max(
+      margin,
+      Math.min(anchor.right - popup.width, viewport.clientWidth - popup.width - margin),
+    );
+    const below = anchor.bottom + gap;
+    const above = anchor.top - gap - popup.height;
+    const preferredTop =
+      below + popup.height > viewport.clientHeight - margin && above >= margin ? above : below;
+    const top = Math.max(
+      margin,
+      Math.min(preferredTop, viewport.clientHeight - popup.height - margin),
+    );
+    element.style.left = `${left}px`;
+    element.style.top = `${top}px`;
+  }
+
+  protected render() {
+    const { compact } = this.$props;
+    const label = this.scope.locale.MoreActions();
+    return (
+      <div class="inline-flex items-center">
+        {compact && (
+          <ZButton
+            key="trigger"
+            id={`${this._id}-trigger`}
+            class="btn btn-ghost btn-square"
+            aria-label={label}
+            aria-controls={this._id}
+            aria-expanded={this._open}
+            {...{ popovertarget: this._id }}
+          >
+            <ZIcon name="::more-horiz" width={24} aria-hidden="true" />
+          </ZButton>
+        )}
+        <div
+          key="actions"
+          ref={ref => this._setActionsRef((ref as HTMLDivElement | null) ?? undefined)}
+          id={this._id}
+          class={
+            compact
+              ? [this._cPopover, 'bg-base-100 border border-base-300 rounded-box shadow-lg p-2']
+              : this.$props.class
+          }
+          {...{ popover: compact ? 'auto' : undefined }}
+          role="group"
+          aria-label={this.scope.locale.RowActions()}
+        >
+          {this.$slotDefault?.()}
+        </div>
+      </div>
+    );
+  }
+}

package/zova/src/suite/cabloy-basic/modules/basic-table/src/component/table/controller.tsx

@@ -1,5 +1,6 @@
 import type {
   BeanControllerTableBase,
+  ControllerTable as ControllerTableInner,
   ControllerTableProps as ControllerTablePropsSuper,
 } from 'zova-module-a-table';
 
@@ -9,12 +10,84 @@ import { Controller } from 'zova-module-a-bean';
 export interface ControllerTableProps<
   TData extends {} = {},
 > extends ControllerTablePropsSuper<TData> {
+  compactBreakpoint?: number | false;
   tableRef?: (ref: BeanControllerTableBase<TData>) => void;
 }
 
 @Controller()
 export class ControllerTable extends BeanControllerBase {
-  static $propsDefault = {};
+  static $propsDefault = { compactBreakpoint: 768 };
 
-  protected async __init__() {}
+  innerTable?: ControllerTableInner<any>;
+  containerWidth: number = 0;
+  popoverSupported: boolean = false;
+  private _container?: HTMLElement;
+  private _observer?: ResizeObserver;
+  private _mounted: boolean = false;
+  private _disposed: boolean = false;
+
+  protected async __init__() {
+    this.$controllerMounted(() => {
+      this.$ssr.handleDirectOrOnHydrated(() => {
+        if (this._disposed) return;
+        this._mounted = true;
+        this.popoverSupported = typeof HTMLElement.prototype.showPopover === 'function';
+        this._observeContainer();
+      });
+    });
+  }
+
+  public get compact() {
+    const breakpoint = this.$props.compactBreakpoint;
+    return (
+      this.popoverSupported &&
+      breakpoint !== false &&
+      this.containerWidth > 0 &&
+      this.containerWidth < (breakpoint ?? 768)
+    );
+  }
+
+  public get columnSizing() {
+    const sizing = { ...this.$props.columnSizing };
+    if (this.compact) {
+      for (const property of this.innerTable?.tableMeta?.properties ?? []) {
+        if (this.isOperationsColumn(property.key!)) sizing[property.key!] = 80;
+      }
+    }
+    return sizing;
+  }
+
+  public isOperationsColumn(key: string) {
+    const table = this.innerTable;
+    if (!table) return false;
+    const scope = table.getColumnScope(key);
+    const { render } = table.getColumnComponentPropsTop(key, scope, {});
+    return table.getRenderProvider(render) === 'basic-table.tableCell.actionOperationsRow';
+  }
+
+  public setContainer(element: HTMLElement | undefined) {
+    if (element === this._container) return;
+    this._observer?.disconnect();
+    this._container = element;
+    this._observeContainer();
+  }
+
+  private _observeContainer() {
+    const container = this._container;
+    if (!this._mounted || this._disposed || !container) return;
+    this._observer?.disconnect();
+    const measure = () => {
+      if (this._disposed || container !== this._container) return;
+      this.containerWidth = container.clientWidth;
+    };
+    measure();
+    this._observer = new ResizeObserver(measure);
+    this._observer.observe(container);
+  }
+
+  protected __dispose__() {
+    this._disposed = true;
+    this._observer?.disconnect();
+    this._container = undefined;
+  }
 }

package/zova/src/suite/cabloy-basic/modules/basic-table/src/component/table/render.tsx

@@ -1,4 +1,4 @@
-import type { AriaAttributes, CSSProperties } from 'vue';
+import type { AriaAttributes, CSSProperties, ComponentPublicInstance } from 'vue';
 
 import { FlexRender } from '@tanstack/vue-table';
 import { BeanRenderBase } from 'zova';
@@ -9,27 +9,39 @@ import { ControllerTable, TableColumnIdSelection, ZTable } from 'zova-module-a-t
 export class RenderTable<TData extends {} = {}> extends BeanRenderBase {
   public render() {
     return (
-      <ZTable
-        data={this.$props.data}
-        schema={this.$props.schema}
-        schemaOrder={this.$props.schemaOrder}
-        sorting={this.$props.sorting}
-        onSortingChange={this.$props.onSortingChange}
-        enableRowSelection={this.$props.enableRowSelection}
-        selectionMode={this.$props.selectionMode}
-        rowSelection={this.$props.rowSelection}
-        onRowSelectionChange={this.$props.onRowSelectionChange}
-        tableScope={this.$props.tableScope}
-        getColumns={this.$props.getColumns}
-        getRowId={this.$props.getRowId}
-        layout={this.$props.layout}
-        controllerRef={ref => {
-          this.$props?.tableRef?.(ref);
+      <div
+        class="min-w-0 max-w-full overflow-x-auto"
+        data-table-compact={this.compact ? 'true' : 'false'}
+        ref={(element: Element | ComponentPublicInstance | null) => {
+          if (this.ctx.disposed) return;
+          this.setContainer?.((element as HTMLElement | null) ?? undefined);
         }}
-        slotDefault={$$table => {
-          return this._renderTable($$table);
-        }}
-      ></ZTable>
+      >
+        <ZTable
+          data={this.$props.data}
+          schema={this.$props.schema}
+          schemaOrder={this.$props.schemaOrder}
+          sorting={this.$props.sorting}
+          onSortingChange={this.$props.onSortingChange}
+          enableRowSelection={this.$props.enableRowSelection}
+          selectionMode={this.$props.selectionMode}
+          rowSelection={this.$props.rowSelection}
+          onRowSelectionChange={this.$props.onRowSelectionChange}
+          tableScope={this.$props.tableScope}
+          getColumns={this.$props.getColumns}
+          getRowId={this.$props.getRowId}
+          layout={this.$props.layout}
+          compact={this.compact}
+          columnSizing={this.columnSizing}
+          controllerRef={ref => {
+            this.innerTable = ref;
+            this.$props?.tableRef?.(ref);
+          }}
+          slotDefault={$$table => {
+            return this._renderTable($$table);
+          }}
+        ></ZTable>
+      </div>
     );
   }
 
@@ -38,7 +50,9 @@ export class RenderTable<TData extends {} = {}> extends BeanRenderBase {
     const fixed = column.getIsPinned();
     const width = column.getSize();
     return {
-      ...(typeof rest?.width === 'number' ? { width: `${width}px`, minWidth: `${width}px` } : {}),
+      ...(typeof rest?.width === 'number' || typeof this.columnSizing[column.id] === 'number'
+        ? { width: `${width}px`, minWidth: `${width}px` }
+        : {}),
       textAlign: rest?.align,
       position: fixed ? ('sticky' as const) : undefined,
       left: fixed === 'left' ? `${column.getStart('left')}px` : undefined,
@@ -75,6 +89,10 @@ export class RenderTable<TData extends {} = {}> extends BeanRenderBase {
                     onChange={table.getToggleAllPageRowsSelectedHandler()}
                   />
                 )
+              ) : this.compact && this.isOperationsColumn(column.id) ? (
+                <span class="sr-only">
+                  <FlexRender render={headerDefinition} props={header.getContext()}></FlexRender>
+                </span>
               ) : (
                 <FlexRender render={headerDefinition} props={header.getContext()}></FlexRender>
               );

package/zova/src/suite/cabloy-basic/modules/basic-table/src/config/locale/en-us.ts

@@ -1,5 +1,9 @@
 export default {
   Create: 'Create',
+  Edit: 'Edit',
+  Delete: 'Delete',
+  MoreActions: 'More actions',
+  RowActions: 'Row actions',
   DeleteConfirm: 'Are you sure you want to delete this item?',
   SelectAllPageRows: 'Select all rows on this page',
   SelectRow: 'Select row %s',

package/zova/src/suite/cabloy-basic/modules/basic-table/src/config/locale/zh-cn.ts

@@ -1,5 +1,9 @@
 export default {
   Create: '创建',
+  Edit: '编辑',
+  Delete: '删除',
+  MoreActions: '更多操作',
+  RowActions: '行操作',
   DeleteConfirm: '您确认要删除本数据吗？',
   SelectAllPageRows: '选择本页所有行',
   SelectRow: '选择行 %s',

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

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