@punica/editor 1.10.2 → 1.10.4

package/package.json

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

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

@@ -112,52 +112,48 @@ 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 {
           variant?: 'filled' | 'outlined' | 'text';
-          color?: 'primary' | 'secondary' | 'error';
+          color?:
+            | 'primary'
+            | 'secondary'
+            | 'error'
+            | 'warning'
+            | 'info'
+            | 'success'
+            | 'ghost';
           size?: 'small' | 'medium' | 'large';
           disabled?: boolean;
           rounded?: boolean;
           icon?: string;
           fullwidth?: boolean;
+          attrs?: Record<string, string>;
+          style?: Record<string, string> | string;
+          className?: string;
         }
 
         interface IconButtonOptions {
           title?: string;
-          size?: 'x-small' | 'small' | 'medium';
+          size?: 'x-small' | 'small' | 'medium' | 'large';
           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 {
-          /**
-           * Every variant `punica-typography` ships a `:host([variant=…])`
-           * rule for, and nothing else.
-           *
-           * This list was previously `'h1'..'h6' | 'body' | 'caption'`, of
-           * which only `caption` was real. An unknown variant is not a
-           * harmless no-op: the component stamps `variant="body1"` on any
-           * element created *without* one, so passing a name it does not
-           * implement suppresses that default and leaves the text at the
-           * inherited size, `inline`, with no `role=heading` and no
-           * `aria-level`. `createTypography` therefore drops anything outside
-           * this list rather than writing it to the DOM.
-           */
           variant?:
             | 'headline1'
             | 'headline2'
@@ -183,6 +179,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 {
@@ -371,6 +392,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>;
@@ -445,6 +484,11 @@ declare module 'punica' {
          * `onClick` receives the click event. It was declared `() => void`,
          * which no handler that needs the event (to stop propagation, or to
          * position a flyout off the cursor) could satisfy.
+         *
+         * A `label` containing `<` is written as **markup**, not text — an
+         * activity-bar entry declares its icon that way. Any label that comes
+         * from an LLM, a file path or user input must not go through it: pass
+         * an empty label and a `createTypography` child instead.
          */
         function createButton(
           label: string,
@@ -504,6 +548,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;