@punica/editor 1.10.1 → 1.10.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@punica/editor",
-  "version": "1.10.1",
+  "version": "1.10.3",
   "description": "Punica Editor",
   "private": false,
   "type": "module",

package/types/punica.module.shell.view.d.ts

@@ -112,6 +112,14 @@ declare module 'punica' {
           children?: HTMLElement[];
           style?: Record<string, string> | string;
           className?: string;
+          /**
+           * Listeners bound as the element is built, keyed by event name:
+           * `{ click: fn, mousedown: fn }`. The component factories already
+           * take an `onClick`; this is the same thing for the plain tags a
+           * view builds by hand, so a tree stays one expression instead of
+           * breaking into a variable plus an `addEventListener` line.
+           */
+          on?: Record<string, EventListener>;
         }
 
         interface ButtonOptions {
@@ -130,6 +138,18 @@ declare module 'punica' {
           variant?: 'text' | 'outlined' | 'filled';
           disabled?: boolean;
           attrs?: Record<string, string>;
+          style?: Record<string, string> | string;
+          className?: string;
+          /**
+           * Finished icon markup, for the cases the positional `iconClass`
+           * cannot express — a toolbar action declares its icon as ready
+           * `<i>`/`<svg>` markup rather than a class name, so wrapping it in
+           * another `<i class=…>` would nest it wrongly.
+           *
+           * Same contract as `IconOptions`: a non-empty `iconClass` wins, and
+           * this is used only when the caller passes an empty one.
+           */
+          innerHTML?: string;
         }
 
         interface TypographyOptions {
@@ -171,6 +191,31 @@ declare module 'punica' {
           variant?: 'filled' | 'outlined';
           color?: 'primary' | 'secondary' | 'error' | 'success' | 'warning';
           size?: 'small' | 'medium';
+          /**
+           * Icon class placed before the label, wrapped in an `<i>`. Same
+           * contract as `createIcon`'s `iconClass`.
+           */
+          icon?: string;
+          /**
+           * Extra content after the label — a chevron on a chip that opens a
+           * menu, a count, a thumbnail. `punica-chip` slots its children, so
+           * these land next to the label rather than replacing it.
+           */
+          children?: HTMLElement[];
+          /**
+           * A dismiss control in the component's `delete` slot. Without this
+           * no slot content is written, so a plain chip is unchanged.
+           */
+          onDelete?: (e: Event) => void;
+          /**
+           * Makes the chip act as a button: `role="button"`, `tabindex="0"`
+           * and Enter/Space alongside the click. The component styles itself
+           * `cursor: unset`, so a chip is inert until this is given.
+           */
+          onClick?: (e: Event) => void;
+          attrs?: Record<string, string>;
+          style?: Record<string, string> | string;
+          className?: string;
         }
 
         interface BoxOptions {
@@ -359,6 +404,24 @@ declare module 'punica' {
           className?: string;
         }
 
+        /**
+         * Where an anchored menu opens. An element is measured with
+         * `getBoundingClientRect`; a bare rect is for the cursor-driven case
+         * (a context menu opens at the pointer, which has no element).
+         */
+        interface MenuAnchorOptions {
+          anchor:
+            | HTMLElement
+            | {
+                top: number;
+                left: number;
+                bottom?: number;
+                width?: number;
+                height?: number;
+              };
+          placement?: 'top' | 'bottom' | 'left' | 'right';
+        }
+
         interface MenuItemOptions {
           text?: string;
           attrs?: Record<string, string>;
@@ -492,6 +555,21 @@ declare module 'punica' {
 
         function createMenuItem(options?: MenuItemOptions): HTMLElement;
 
+        /**
+         * Opens a `punica-menu` beside something. The component does the rest
+         * — backdrop, Escape, and flipping when the menu does not fit — but it
+         * reads the position off `top`/`left`/`width`/`height`/`bottom`/
+         * `placement` attributes, which every caller was measuring and writing
+         * by hand.
+         */
+        function openMenuAt(
+          menu: HTMLElement,
+          options: MenuAnchorOptions
+        ): void;
+
+        /** Closes an open menu. The component fires `close` as it hides. */
+        function closeMenu(menu: HTMLElement): void;
+
         /** A resizable pane container. Children become the panes, in order. */
         function createSplit(options?: SplitOptions): HTMLElement;