ooxml-ui 1.24.0 → 1.26.0

package/dist/bindings/contract.d.ts

@@ -0,0 +1,115 @@
+import type { Equality } from './equality.js';
+import type { HandleSpec } from './handle.js';
+/** How `bindElement` forwards one prop to the element. */
+export type ForwardPolicy = 
+/** Written on every update: settings the user cannot change inside the element. */
+'always'
+/** Written the first time and then only when the prop changed since it was last written. */
+ | 'changed'
+/**
+ * Like `changed`, but an undefined prop is skipped and not remembered, so the element keeps
+ * what the user chose (File > Open renames the document; a later re-render must not undo it).
+ */
+ | 'defined'
+/** Not forwarded by the kit: the product's mount function owns it (ordering, supersession). */
+ | 'manual';
+export interface PropRule<E = never, V = unknown> {
+    readonly forward: ForwardPolicy;
+    /** Compared and written in place of an undefined prop. */
+    readonly fallback?: V;
+    /** Default `Object.is`. */
+    readonly same?: Equality<V>;
+    /** Counts as already written at mount, so an equal first value is not written. */
+    readonly initial?: V;
+    /** Writes the value; default `element[key] = value`. */
+    readonly apply?: (element: E, value: V) => void;
+}
+/**
+ * Two-way binding of an event to a prop (`v-model:readOnly`, Angular `[(readOnly)]`): the adapter
+ * emits `value(...args)` back to the prop when it differs from the prop's current value.
+ */
+export interface EventModel {
+    readonly prop: string;
+    readonly value: (...args: never[]) => unknown;
+}
+export interface EventRule<O extends string = string> {
+    /** The handler option the event calls (`onDocumentChange`). */
+    readonly option: O;
+    /** The handler's arguments; default the event's `detail` alone. */
+    readonly args?: (event: CustomEvent) => readonly unknown[];
+    readonly model?: EventModel;
+}
+/** Argument shapes shared by the products' events. */
+export declare const eventArgs: {
+    /** The unwrapped detail (the default). */
+    readonly detail: (event: CustomEvent) => readonly unknown[];
+    /** The event itself, for cancelable events (`file-command`: call `preventDefault()`). */
+    readonly event: (event: CustomEvent) => readonly unknown[];
+    /** `(detail, event)`: the detail, plus the event to cancel (`teams-open-file`). */
+    readonly detailAndEvent: (event: CustomEvent) => readonly unknown[];
+    /** `(readOnly, detail)` for `readonly-change`. */
+    readonly readOnly: (event: CustomEvent<{
+        readOnly: boolean;
+    }>) => readonly unknown[];
+    /** One field of the detail (`dirty-change` carries `{ dirty }`). */
+    readonly field: (name: string) => (event: CustomEvent) => readonly unknown[];
+};
+/**
+ * `readonly-change` with `v-model:readOnly`: the model mirrors the host's own switch
+ * (`detail.hostReadOnly`), never a collaboration role lock.
+ */
+export declare const readOnlyChange: EventRule<'onReadOnlyChange'>;
+/**
+ * The contract of one product binding. `props` lists every forwarded prop in forwarding order,
+ * `events` maps each element event to its handler option, `handle` lists the handle members.
+ */
+export interface BindingContract<E = never, P extends object = Record<string, unknown>, H = unknown, N extends string = string, O extends string = string> {
+    readonly props: {
+        readonly [K in keyof P]-?: PropRule<E, P[K]>;
+    };
+    readonly events: {
+        readonly [K in N]: EventRule<O>;
+    };
+    readonly handle: HandleSpec<H>;
+}
+/** What every product's mount function returns: options in, teardown out. */
+export interface MountedBinding<O> {
+    update(options: O): void;
+    destroy(): void;
+}
+/** Any contract, for the functions that only read its names. */
+export interface AnyContract {
+    readonly props: object;
+    readonly events: Readonly<Record<string, EventRule>>;
+    readonly handle: object;
+}
+export declare function propKeys(contract: Pick<AnyContract, 'props'>): string[];
+export declare function eventNames(contract: Pick<AnyContract, 'events'>): string[];
+/** The handler option names (`onDocumentChange`), in event order. */
+export declare function optionNames(contract: Pick<AnyContract, 'events'>): string[];
+/** Svelte callback props are the lower-case option: `onDocumentChange` is `ondocumentchange`. */
+export declare const svelteHandlerName: (option: string) => string;
+/** Angular outputs drop the `on`: `onDocumentChange` is `documentChange`. */
+export declare const angularOutputName: (option: string) => string;
+/**
+ * Copies the contract's props out of a framework's props or component instance. `undefined`
+ * values are copied too (meaning "not provided") unless `definedOnly` drops them.
+ */
+export declare function pickProps<P extends object>(contract: Pick<AnyContract, 'props'>, source: object, definedOnly?: boolean): P;
+/** Maps handlers keyed by event name onto the contract's handler options. */
+export declare function eventOptions<O extends object>(contract: Pick<AnyContract, 'events'>, handlers: object): O;
+/**
+ * Reads the handler options out of a framework's props, where each one is named `nameOf(option)`
+ * (identity for React and Solid, `svelteHandlerName` for Svelte). `extra` adds options that are
+ * not element events (`onReady`).
+ */
+export declare function handlerOptions<O extends object>(contract: Pick<AnyContract, 'events'>, source: object, nameOf?: (option: string) => string, extra?: readonly string[]): O;
+/** Props plus handler options: what a product's mount function takes. */
+export declare function contractOptions<O extends object>(contract: Pick<AnyContract, 'props' | 'events'>, source: object, nameOf?: (option: string) => string, extra?: readonly string[]): O;
+/**
+ * Handler options that emit an Angular component's outputs: each option emits the output named
+ * `angularOutputName(option)` with the handler's first argument. A modelled event emits only its
+ * model (`readOnlyChange` with the host's switch) and only when the input differs. `overrides`
+ * replaces individual options (an output that carries two values).
+ */
+export declare function angularOutputs<O extends object>(contract: Pick<AnyContract, 'events'>, component: object, extra?: readonly string[], overrides?: Partial<O>): O;

package/dist/bindings/equality.d.ts

@@ -0,0 +1,9 @@
+/** Compares two values the way a prop forwarder does. */
+export type Equality<T = unknown> = (a: T, b: T) => boolean;
+/** Same items in the same order; `undefined` and `null` count as an empty list. */
+export declare function sameList(a: readonly unknown[] | undefined | null, b: readonly unknown[] | undefined | null): boolean;
+/**
+ * Shallow, by value: an inline object (`themeColors`) passed on every render is not a change.
+ * `undefined` and `null` count as an empty object.
+ */
+export declare function shallowEqual(a: object | undefined | null, b: object | undefined | null): boolean;

package/dist/bindings/handle.d.ts

@@ -0,0 +1,33 @@
+/**
+ * How one handle member behaves while nothing is mounted:
+ * - `get`: a property; reading it throws (or gives `undefined` with `lenientGetters`).
+ * - `call`: a method; calling it throws.
+ * - `async`: a method returning a promise; calling it rejects.
+ * - `optional-call`: a method that does nothing (`markClean` before mount is harmless).
+ * - `{ fallback }`: a property that reads `fallback` (`dirty` is `false`).
+ */
+export type HandleMember = 'get' | 'call' | 'async' | 'optional-call' | {
+    readonly fallback: unknown;
+};
+/** One entry per member of the handle `H`; a missing member is a compile error. */
+export type HandleSpec<H> = {
+    readonly [K in keyof H]-?: HandleMember;
+};
+export interface DeferredHandleOptions {
+    /** The error thrown before mount and after unmount. Default `Editor is not mounted`. */
+    readonly message?: string;
+    /** `get` members read `undefined` instead of throwing (Vue templates read refs before mount). */
+    readonly lenientGetters?: boolean;
+}
+/** The member names of a handle spec, in declaration order. */
+export declare function handleKeys<H>(spec: HandleSpec<H>): (keyof H & string)[];
+/**
+ * A handle for adapters whose binding may not be mounted yet: every member reads the current
+ * binding, so one handle object serves the whole lifetime of the component.
+ */
+export declare function deferredHandle<H>(spec: HandleSpec<H>, current: () => H | null | undefined, options?: DeferredHandleOptions): H;
+/**
+ * Defines the handle members on a class prototype (an Angular component), reading the binding of
+ * each instance through `current`. Declare the members on the class with an interface merge.
+ */
+export declare function installHandle<H, T>(prototype: T, spec: HandleSpec<H>, current: (self: T) => H | null | undefined, options?: DeferredHandleOptions): void;

package/dist/bindings/index.d.ts

@@ -0,0 +1,6 @@
+export { angularOutputName, angularOutputs, contractOptions, eventArgs, eventNames, eventOptions, handlerOptions, optionNames, pickProps, propKeys, readOnlyChange, svelteHandlerName, type AnyContract, type BindingContract, type EventModel, type EventRule, type ForwardPolicy, type MountedBinding, type PropRule, } from './contract.js';
+export { bindElement, listenEvents, syncClassName, type BindElementOptions, type BoundElement, type Unlisten, } from './bind-element.js';
+export { sameList, shallowEqual, type Equality } from './equality.js';
+export { deferredHandle, handleKeys, installHandle, type DeferredHandleOptions, type HandleMember, type HandleSpec, } from './handle.js';
+export { createSrcLoader, nameFromUrl, type SrcLoader } from './src-loader.js';
+export { createPropTracker, type PropTracker } from './tracker.js';

package/dist/bindings/react.d.ts

@@ -0,0 +1,21 @@
+import { type ForwardRefExoticComponent, type PropsWithoutRef, type RefAttributes } from 'react';
+import type { MountedBinding } from './contract.js';
+import { type DeferredHandleOptions, type HandleSpec } from './handle.js';
+export interface ReactBindingConfig<Props, O, B, H> {
+    displayName: string;
+    /** The members the component's `ref` exposes. */
+    handle: HandleSpec<H>;
+    handleOptions?: DeferredHandleOptions;
+    /** Creates the element inside `host`; the binding it returns also serves the handle. */
+    mount(host: HTMLDivElement, options: O): B;
+    /** The mount options for a render's props; default the props themselves. */
+    options?: (props: Props) => O;
+    /** Attributes of the host `<div>`; default `{ className: props.className }`. */
+    host?: (props: Props) => Record<string, unknown>;
+}
+/**
+ * A `forwardRef` component that mounts once, forwards every render's props through
+ * `binding.update` (the binding itself skips unchanged values) and exposes a handle that throws a
+ * clear error before mount.
+ */
+export declare function createReactBinding<Props extends object, H, O = Props, B extends MountedBinding<O> = MountedBinding<O>>(config: ReactBindingConfig<Props, O, B, H>): ForwardRefExoticComponent<PropsWithoutRef<Props> & RefAttributes<H>>;

package/dist/bindings/react.js

@@ -0,0 +1,39 @@
+import { deferredHandle } from '../chunk-KJMAVPQB.js';
+import { forwardRef, useRef, useEffect, useImperativeHandle, createElement } from 'react';
+
+var defaultHost = (props) => ({
+  className: props.className
+});
+function createReactBinding(config) {
+  const toOptions = config.options ?? ((props) => props);
+  const hostProps = config.host ?? defaultHost;
+  const component = forwardRef(function Binding(props, ref) {
+    const host = useRef(null);
+    const binding = useRef(null);
+    useEffect(() => {
+      const mounted = config.mount(host.current, toOptions(props));
+      binding.current = mounted;
+      return () => {
+        binding.current = null;
+        mounted.destroy();
+      };
+    }, []);
+    useEffect(() => {
+      binding.current?.update(toOptions(props));
+    }, [props]);
+    useImperativeHandle(
+      ref,
+      () => deferredHandle(
+        config.handle,
+        () => binding.current,
+        config.handleOptions
+      ),
+      []
+    );
+    return createElement("div", { ref: host, ...hostProps(props) });
+  });
+  component.displayName = config.displayName;
+  return component;
+}
+
+export { createReactBinding };

package/dist/bindings/solid.d.ts

@@ -0,0 +1,14 @@
+import type { MountedBinding } from './contract.js';
+import { type DeferredHandleOptions, type HandleSpec } from './handle.js';
+export interface SolidBindingConfig<Props, O, B, H> {
+    handle: HandleSpec<H>;
+    handleOptions?: DeferredHandleOptions;
+    mount(host: HTMLDivElement, options: O): B;
+    /** The mount options; reading each prop here is what makes the effect track it. */
+    options(props: Props): O;
+    /** The callback prop that receives the handle once mounted. Default `editorRef`. */
+    ref?: string;
+}
+export declare function createSolidBinding<Props extends {
+    class?: string | undefined;
+}, H, O, B extends MountedBinding<O> = MountedBinding<O>>(config: SolidBindingConfig<Props, O, B, H>): (props: Props) => HTMLDivElement;

package/dist/bindings/solid.js

@@ -0,0 +1,27 @@
+import { deferredHandle } from '../chunk-KJMAVPQB.js';
+import { createSignal, onMount, createEffect, onCleanup } from 'solid-js';
+
+function createSolidBinding(config) {
+  const refName = config.ref ?? "editorRef";
+  return function Binding(props) {
+    const host = document.createElement("div");
+    const [binding, setBinding] = createSignal();
+    onMount(() => {
+      const mounted = config.mount(host, config.options(props));
+      setBinding(() => mounted);
+      const ref = props[refName];
+      if (typeof ref === "function")
+        ref(deferredHandle(config.handle, () => mounted, config.handleOptions));
+    });
+    createEffect(() => {
+      const current = binding();
+      if (!current) return;
+      host.className = props.class ?? "";
+      current.update(config.options(props));
+    });
+    onCleanup(() => binding()?.destroy());
+    return host;
+  };
+}
+
+export { createSolidBinding };

package/dist/bindings/src-loader.d.ts

@@ -0,0 +1,14 @@
+/** The file name in a URL's last path segment; the raw segment when it is not valid %-encoding. */
+export declare function nameFromUrl(url: string): string | undefined;
+export interface SrcLoader {
+    /** Fetches `url` and loads it, superseding any fetch still in flight. */
+    fetch(url: string, fileName: string | undefined): void;
+    /** Drops the fetch in flight (new bytes or a model arrived, `src` was cleared, or destroy). */
+    cancel(): void;
+}
+/**
+ * Every failure in the chain (fetch throwing, HTTP errors, reading the body, naming) is reported
+ * through `report`; a superseded fetch is aborted and neither loads nor reports. Without an explicit
+ * file name the URL's last segment names the file.
+ */
+export declare function createSrcLoader(load: (bytes: Uint8Array, fileName: string | undefined) => Promise<void>, report: (error: unknown) => void): SrcLoader;

package/dist/bindings/tracker.d.ts

@@ -0,0 +1,14 @@
+import type { Equality } from './equality.js';
+/**
+ * Remembers the last value forwarded for each prop. Calling it returns true the first time and then
+ * only when the prop itself changed, so a parent re-render never undoes a value the user changed
+ * inside the element (Editing / Viewing, File > Open renaming the document, Customize Ribbon).
+ */
+export interface PropTracker<K extends string = string> {
+    <T>(key: K, value: T, same?: Equality<T>): boolean;
+    /** Records `value` as already forwarded, so an equal first value is not written. */
+    seed(key: K, value: unknown): void;
+    /** The value last forwarded for `key`; `undefined` before the first. */
+    sent(key: K): unknown;
+}
+export declare function createPropTracker<K extends string = string>(): PropTracker<K>;

package/dist/bindings/vue.d.ts

@@ -0,0 +1,35 @@
+import { type ComponentObjectPropsOptions } from 'vue';
+import { type AnyContract, type MountedBinding } from './contract.js';
+import { type DeferredHandleOptions, type HandleSpec } from './handle.js';
+type Emit = (event: string, ...args: unknown[]) => void;
+export interface VueBindingConfig<PO, O, B, H> {
+    name: string;
+    /** Vue's runtime prop declarations (types, Boolean casting, defaults). */
+    props: PO;
+    /** Generates the emits and the default mount options. */
+    contract: Pick<AnyContract, 'props' | 'events'>;
+    /** Options that are not element events, emitted under their own name (`{ ready: 'onReady' }`). */
+    callbacks?: Readonly<Record<string, string>>;
+    /** Replaces the generated emits. */
+    emits?: readonly string[];
+    handle: HandleSpec<H>;
+    /** Default `{ lenientGetters: true }`: a template may read `element` before mount. */
+    handleOptions?: DeferredHandleOptions;
+    mount(host: HTMLElement, options: O): B;
+    /** Replaces the generated mount options (props plus one emitting handler per event). */
+    options?: (props: Record<string, unknown>, emit: Emit) => O;
+}
+/** The emits a contract generates: every event, `update:<prop>` per model, then the callbacks. */
+export declare function vueEmits(contract: Pick<AnyContract, 'events'>, callbacks?: Readonly<Record<string, string>>): string[];
+/** Handler options that re-emit each event (and its model) from a Vue component. */
+export declare function vueEmitters(contract: Pick<AnyContract, 'events'>, props: Record<string, unknown>, emit: Emit, callbacks?: Readonly<Record<string, string>>): Record<string, (...args: unknown[]) => void>;
+export declare function defineVueBinding<PO extends ComponentObjectPropsOptions, H, O = Record<string, unknown>, B extends MountedBinding<O> = MountedBinding<O>>(config: VueBindingConfig<PO, O, B, H>): import("vue").DefineComponent<ComponentObjectPropsOptions<{
+    [x: string]: unknown;
+}> extends PO ? {} : import("vue").ExtractPropTypes<PO>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, string[], string, import("vue").PublicProps, Readonly<ComponentObjectPropsOptions<{
+    [x: string]: unknown;
+}> extends PO ? {} : import("vue").ExtractPropTypes<PO>> & Readonly<{
+    [x: `on${Capitalize<string>}`]: ((...args: any[]) => any) | undefined;
+}>, import("vue").ExtractDefaultPropTypes<PO>, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export {};

package/dist/bindings/vue.js

@@ -0,0 +1,65 @@
+import { pickProps } from '../chunk-NDUD5JJB.js';
+import { deferredHandle } from '../chunk-KJMAVPQB.js';
+import { defineComponent, ref, shallowRef, onMounted, watch, onBeforeUnmount, h } from 'vue';
+
+function vueEmits(contract, callbacks = {}) {
+  const models = Object.values(contract.events).flatMap(
+    (rule) => rule.model ? [`update:${rule.model.prop}`] : []
+  );
+  return [...Object.keys(contract.events), ...models, ...Object.keys(callbacks)];
+}
+function vueEmitters(contract, props, emit, callbacks = {}) {
+  const options = {};
+  for (const [name, rule] of Object.entries(contract.events)) {
+    const model = rule.model;
+    options[rule.option] = (...args) => {
+      emit(name, ...args);
+      if (!model) return;
+      const value = model.value(...args);
+      if (value !== props[model.prop]) emit(`update:${model.prop}`, value);
+    };
+  }
+  for (const [name, option] of Object.entries(callbacks))
+    options[option] = (...args) => emit(name, ...args);
+  return options;
+}
+function defineVueBinding(config) {
+  const callbacks = config.callbacks ?? {};
+  const keys = Object.keys(config.props);
+  return defineComponent({
+    name: config.name,
+    props: config.props,
+    emits: [...config.emits ?? vueEmits(config.contract, callbacks)],
+    setup(props, { emit, expose }) {
+      const values = props;
+      const host = ref();
+      const binding = shallowRef();
+      const options = () => config.options ? config.options(values, emit) : {
+        ...pickProps(config.contract, values),
+        ...vueEmitters(config.contract, values, emit, callbacks)
+      };
+      onMounted(() => {
+        binding.value = config.mount(host.value, options());
+      });
+      watch(
+        () => keys.map((key) => values[key]),
+        () => binding.value?.update(options())
+      );
+      onBeforeUnmount(() => {
+        const mounted = binding.value;
+        binding.value = void 0;
+        mounted?.destroy();
+      });
+      expose(
+        deferredHandle(
+          config.handle,
+          () => binding.value,
+          config.handleOptions ?? { lenientGetters: true }
+        )
+      );
+      return () => h("div", { ref: host });
+    }
+  });
+}
+
+export { defineVueBinding, vueEmits, vueEmitters };

package/dist/bindings.js

@@ -0,0 +1,3 @@
+export { bindElement, createPropTracker, createSrcLoader, listenEvents, nameFromUrl, sameList, shallowEqual, syncClassName } from './chunk-CDAXY5KC.js';
+export { angularOutputName, angularOutputs, contractOptions, eventArgs, eventNames, eventOptions, handlerOptions, optionNames, pickProps, propKeys, readOnlyChange, svelteHandlerName } from './chunk-NDUD5JJB.js';
+export { deferredHandle, handleKeys, installHandle } from './chunk-KJMAVPQB.js';

package/dist/chart/data-sheet-keys.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Keyboard behaviour of the chart data sheet, as a pure decision so it is tested without a DOM.
+ * It follows the spreadsheet PowerPoint opens for Edit Data:
+ *
+ * - a focused cell is `ready`: arrows move to the neighbouring cell, typing replaces the text
+ *   and enters `enter` mode, F2 enters `edit` mode with the caret at the end;
+ * - in `enter` mode arrows commit and move, in `edit` mode they move the caret;
+ * - Enter commits and moves down (Shift+Enter up), Tab right (Shift+Tab left); Tab past the last
+ *   column and Shift+Tab before the first leave the sheet, as they would leave any field;
+ * - Escape restores the cell's text and returns to `ready`.
+ *
+ * Cells use the grid coordinates of `ooxml-core/chart` `data-sheet`: row 0 is the series names,
+ * column 0 the category labels, and the corner cell (0, 0) does not exist.
+ */
+export type ChartDataSheetMode = 'ready' | 'enter' | 'edit';
+export interface ChartDataSheetKey {
+    key: string;
+    shiftKey?: boolean;
+    ctrlKey?: boolean;
+    metaKey?: boolean;
+    altKey?: boolean;
+}
+export type ChartDataSheetKeyAction = {
+    type: 'move';
+    row: number;
+    col: number;
+} | {
+    type: 'edit';
+} | {
+    type: 'revert';
+} | {
+    type: 'typing';
+} | {
+    type: 'native';
+};
+/** What a key does in a cell at (`row`, `col`) of a sheet `rows` x `cols` (corner included). */
+export declare function chartDataSheetKeyAction(key: ChartDataSheetKey, mode: ChartDataSheetMode, row: number, col: number, rows: number, cols: number): ChartDataSheetKeyAction;
+//# sourceMappingURL=data-sheet-keys.d.ts.map

package/dist/chart/data-sheet-keys.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-sheet-keys.d.ts","sourceRoot":"","sources":["../../src/chart/data-sheet-keys.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,MAAM,MAAM,kBAAkB,GAAG,OAAO,GAAG,OAAO,GAAG,MAAM,CAAC;AAE5D,MAAM,WAAW,iBAAiB;IACjC,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,MAAM,CAAC,EAAE,OAAO,CAAC;CACjB;AAED,MAAM,MAAM,uBAAuB,GAChC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,GAC1C;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,GAChB;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,GAClB;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,GAClB;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,CAAC;AAwBtB,gGAAgG;AAChG,wBAAgB,uBAAuB,CACtC,GAAG,EAAE,iBAAiB,EACtB,IAAI,EAAE,kBAAkB,EACxB,GAAG,EAAE,MAAM,EACX,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,GACV,uBAAuB,CAyBzB"}

package/dist/chart/data-sheet-labels.d.ts

@@ -0,0 +1,36 @@
+import type { ChartDataSheet, ChartDataSheetEdit } from 'ooxml-core/chart';
+/**
+ * Translated text of the sheet. `{number}`, `{name}`, `{series}` and `{categories}` in a template
+ * (or the i18next form, `{{number}}`) are replaced with the cell's position, series name and the
+ * counts.
+ */
+export interface OfficeChartDataSheetLabels {
+    heading: string;
+    addCategory: string;
+    addSeries: string;
+    addCategoryShort: string;
+    addSeriesShort: string;
+    removeCategory: string;
+    removeSeries: string;
+    categories: string;
+    seriesName: string;
+    categoryLabel: string;
+    valueCell: string;
+    summary: string;
+    invalidNumber: string;
+}
+export declare const CHART_DATA_SHEET_ENGLISH: OfficeChartDataSheetLabels;
+/** The cell the host marks (a chart part picked on the canvas): a value, or a whole series. */
+export interface OfficeChartDataSheetHighlight {
+    series: number;
+    point?: number;
+}
+/** Detail of `office-chart-data-change`: the edits in order, and the sheet after them. */
+export interface OfficeChartDataChange {
+    edits: ChartDataSheetEdit[];
+    data: ChartDataSheet;
+}
+export type OfficeChartDataChangeEvent = CustomEvent<OfficeChartDataChange>;
+/** Fills a label template's `{key}` (or `{{key}}`) placeholders. */
+export declare function fill(template: string, values: Record<string, string | number>): string;
+//# sourceMappingURL=data-sheet-labels.d.ts.map

package/dist/chart/data-sheet-labels.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-sheet-labels.d.ts","sourceRoot":"","sources":["../../src/chart/data-sheet-labels.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAE3E;;;;GAIG;AACH,MAAM,WAAW,0BAA0B;IAC1C,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,gBAAgB,EAAE,MAAM,CAAC;IACzB,cAAc,EAAE,MAAM,CAAC;IACvB,cAAc,EAAE,MAAM,CAAC;IACvB,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,aAAa,EAAE,MAAM,CAAC;IACtB,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,aAAa,EAAE,MAAM,CAAC;CACtB;AAED,eAAO,MAAM,wBAAwB,EAAE,0BActC,CAAC;AAEF,+FAA+F;AAC/F,MAAM,WAAW,6BAA6B;IAC7C,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;CACf;AAED,0FAA0F;AAC1F,MAAM,WAAW,qBAAqB;IACrC,KAAK,EAAE,kBAAkB,EAAE,CAAC;IAC5B,IAAI,EAAE,cAAc,CAAC;CACrB;AACD,MAAM,MAAM,0BAA0B,GAAG,WAAW,CAAC,qBAAqB,CAAC,CAAC;AAE5E,oEAAoE;AACpE,wBAAgB,IAAI,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,GAAG,MAAM,CAItF"}

package/dist/chart/data-sheet.d.ts

@@ -0,0 +1,68 @@
+import { type ChartDataSheet, type ChartDataSheetEdit } from 'ooxml-core/chart';
+import { OfficeElement } from '../base.js';
+import { type OfficeChartDataSheetHighlight, type OfficeChartDataSheetLabels } from './data-sheet-labels.js';
+export type { OfficeChartDataChange, OfficeChartDataChangeEvent, OfficeChartDataSheetHighlight, OfficeChartDataSheetLabels, } from './data-sheet-labels.js';
+/**
+ * `<office-ui-chart-data-sheet>`: the categories x series table of a chart's "Edit Data" view,
+ * shared by every product. Series names run across the header row, category labels down the
+ * first column, values in between; the toolbar adds a category or a series and each header has a
+ * remove button while more than one is left. Arrow keys, Enter, Tab, F2 and Escape behave as in
+ * the spreadsheet PowerPoint opens; pasting a tab-separated block (from Excel, Word or this sheet)
+ * fills cells from the focused one, adding the series and categories it needs. Values are read and
+ * shown in `locale`'s number convention (the browser's when unset, as Office follows the system's); a value that is not a number is refused and the cell
+ * restored. The host sets `data` (`{ categories, series: [{ name, values }] }`), `labels`
+ * (translated), `highlight` and `disabled`, and maps `office-chart-data-change`
+ * `{ edits, data }` onto its own chart model; the sheet shows the edited data at once and takes
+ * whatever `data` the host sets next.
+ */
+export declare class OfficeUiChartDataSheet extends OfficeElement {
+    static styles: import("lit").CSSResult[];
+    static properties: {
+        data: {
+            attribute: boolean;
+        };
+        highlight: {
+            attribute: boolean;
+        };
+        disabled: {
+            type: BooleanConstructor;
+            reflect: boolean;
+        };
+        locale: {
+            type: StringConstructor;
+        };
+    };
+    data: ChartDataSheet;
+    highlight: OfficeChartDataSheetHighlight | null;
+    disabled: boolean;
+    locale: string;
+    private text;
+    private mode;
+    private invalid;
+    private highlightKey;
+    constructor();
+    get labels(): OfficeChartDataSheetLabels;
+    set labels(value: Partial<OfficeChartDataSheetLabels>);
+    /** The number convention: `locale`, else the browser's, as Office follows the system locale. */
+    private get language();
+    private parse;
+    /** The text a cell shows for the current data. */
+    private cellText;
+    /**
+     * Applies `edits` to the shown data and emits them. Product subclasses override this to map
+     * the edits onto their own model as well.
+     */
+    protected emitEdits(edits: ChartDataSheetEdit[]): void;
+    private position;
+    private commit;
+    private focusCell;
+    private onKeyDown;
+    private onFocus;
+    private onPaste;
+    protected updated(): void;
+    private cell;
+    private removeButton;
+    protected render(): import("lit").TemplateResult<1>;
+}
+export declare const defineChartDataSheet: import("../registry.js").Definer;
+//# sourceMappingURL=data-sheet.d.ts.map

package/dist/chart/data-sheet.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-sheet.d.ts","sourceRoot":"","sources":["../../src/chart/data-sheet.ts"],"names":[],"mappings":"AAEA,OAAO,EAIN,KAAK,cAAc,EACnB,KAAK,kBAAkB,EACvB,MAAM,kBAAkB,CAAC;AAE1B,OAAO,EAAE,aAAa,EAAiB,MAAM,SAAS,CAAC;AAGvD,OAAO,EAIN,KAAK,6BAA6B,EAClC,KAAK,0BAA0B,EAC/B,MAAM,qBAAqB,CAAC;AAG7B,YAAY,EACX,qBAAqB,EACrB,0BAA0B,EAC1B,6BAA6B,EAC7B,0BAA0B,GAC1B,MAAM,qBAAqB,CAAC;AAI7B;;;;;;;;;;;;GAYG;AACH,qBAAa,sBAAuB,SAAQ,aAAa;IACxD,OAAgB,MAAM,4BAAsB;IAC5C,OAAgB,UAAU;QACzB,IAAI;YAAI,SAAS;;QACjB,SAAS;YAAI,SAAS;;QACtB,QAAQ;YAAI,IAAI;YAAW,OAAO;;QAClC,MAAM;YAAI,IAAI;;MACb;IACM,IAAI,EAAE,cAAc,CAAC;IACrB,SAAS,EAAE,6BAA6B,GAAG,IAAI,CAAC;IAChD,QAAQ,EAAE,OAAO,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IAEvB,OAAO,CAAC,IAAI,CAAuC;IACnD,OAAO,CAAC,IAAI,CAA+B;IAC3C,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,YAAY,CAAuB;IAE3C,cAMC;IAED,IAAI,MAAM,IAAI,0BAA0B,CAEvC;IACD,IAAI,MAAM,CAAC,KAAK,EAAE,OAAO,CAAC,0BAA0B,CAAC,EAGpD;IAED,gGAAgG;IAChG,OAAO,KAAK,QAAQ,GAEnB;IAED,OAAO,CAAC,KAAK,CAAyE;IAEtF,kDAAkD;IAClD,OAAO,CAAC,QAAQ;IAOhB;;;OAGG;IACH,SAAS,CAAC,SAAS,CAAC,KAAK,EAAE,kBAAkB,EAAE,GAAG,IAAI,CAKrD;IAED,OAAO,CAAC,QAAQ;IAIhB,OAAO,CAAC,MAAM;IASd,OAAO,CAAC,SAAS;IAQjB,OAAO,CAAC,SAAS;IA6BjB,OAAO,CAAC,OAAO;IAKf,OAAO,CAAC,OAAO;IASf,UAAmB,OAAO,IAAI,IAAI,CAUjC;IAED,OAAO,CAAC,IAAI;IAmBZ,OAAO,CAAC,YAAY;IAWpB,UAAmB,MAAM,oCAqFxB;CACD;AAED,eAAO,MAAM,oBAAoB,+BAGhC,CAAC"}

package/dist/chart/design-galleries.d.ts

@@ -0,0 +1,52 @@
+/**
+ * The Chart Design galleries every product shares: Chart Styles (the curated presets of
+ * `ooxml-core/chart` `style-presets`), Change Colors (Colorful Palettes 1-4 and Monochromatic
+ * Palettes 1-13, `color-palettes`) and Quick Layout (Layout 1-11, `quick-layouts`). Each builder
+ * returns DOM-free section data with English labels and SVG tiles; a product maps it onto its own
+ * ribbon gallery (PowerPoint's `RibbonGalleryModule`, Excel's gallery control) and translates the
+ * label templates, then applies a pick through its chart edit path (`chart/edit`
+ * `applyChartStylePreset`, `applyChartColorPalette`, `applyChartQuickLayout`, or the product's own
+ * model mapping of them).
+ *
+ * @module chart/design-galleries
+ */
+import { type ChartColorScheme } from 'ooxml-core/chart';
+/** One gallery tile. `label` is English; `labelTemplate` + `labelParams` translate it. */
+export interface ChartGalleryItem {
+    id: string;
+    label: string;
+    labelTemplate: string;
+    labelParams?: Record<string, number>;
+    previewSvg: string;
+    applied: boolean;
+}
+export interface ChartGallerySection {
+    id: string;
+    /** English section title, when the gallery has sections. */
+    title?: string;
+    columns: number;
+    tileWidth: number;
+    tileHeight: number;
+    items: ChartGalleryItem[];
+}
+export declare const CHART_STYLE_TILE: {
+    readonly width: 60;
+    readonly height: 44;
+};
+export declare const CHART_COLOR_TILE: {
+    readonly width: 96;
+    readonly height: 14;
+};
+export declare const CHART_LAYOUT_TILE: {
+    readonly width: 56;
+    readonly height: 44;
+};
+/** Chart Styles: one section of the curated presets; `appliedId` marks the current one. */
+export declare function chartStyleGallerySection(appliedId?: string): ChartGallerySection;
+/** Change Colors: the Colorful and Monochromatic sections resolved under `scheme`. */
+export declare function chartColorGallerySections(scheme: ChartColorScheme, appliedId?: number): ChartGallerySection[];
+/** Quick Layout: Layout 1-11; `appliedN` marks the layout the chart shows. */
+export declare function chartQuickLayoutGallerySection(appliedN?: number): ChartGallerySection;
+/** The layout number of a Quick Layout item id (`layout5` is 5), or `undefined`. */
+export declare function chartQuickLayoutItemNumber(id: string): number | undefined;
+//# sourceMappingURL=design-galleries.d.ts.map

package/dist/chart/design-galleries.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"design-galleries.d.ts","sourceRoot":"","sources":["../../src/chart/design-galleries.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,OAAO,EAMN,KAAK,gBAAgB,EACrB,MAAM,kBAAkB,CAAC;AAI1B,0FAA0F;AAC1F,MAAM,WAAW,gBAAgB;IAChC,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,aAAa,EAAE,MAAM,CAAC;IACtB,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACrC,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,OAAO,CAAC;CACjB;AAED,MAAM,WAAW,mBAAmB;IACnC,EAAE,EAAE,MAAM,CAAC;IACX,4DAA4D;IAC5D,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,gBAAgB,EAAE,CAAC;CAC1B;AAED,eAAO,MAAM,gBAAgB;aAAK,KAAK,EAAE,EAAE;aAAE,MAAM,EAAE,EAAE;CAAW,CAAC;AACnE,eAAO,MAAM,gBAAgB;aAAK,KAAK,EAAE,EAAE;aAAE,MAAM,EAAE,EAAE;CAAW,CAAC;AACnE,eAAO,MAAM,iBAAiB;aAAK,KAAK,EAAE,EAAE;aAAE,MAAM,EAAE,EAAE;CAAW,CAAC;AAEpE,2FAA2F;AAC3F,wBAAgB,wBAAwB,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,mBAAmB,CAchF;AAwBD,sFAAsF;AACtF,wBAAgB,yBAAyB,CACxC,MAAM,EAAE,gBAAgB,EACxB,SAAS,CAAC,EAAE,MAAM,GAChB,mBAAmB,EAAE,CAWvB;AAED,8EAA8E;AAC9E,wBAAgB,8BAA8B,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,mBAAmB,CAerF;AAED,oFAAoF;AACpF,wBAAgB,0BAA0B,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAIzE"}

package/dist/chart/format-pane-3d.d.ts

@@ -0,0 +1,7 @@
+import type { ChartFormatSection } from './format-pane-types.js';
+import type { ChartFormatThreeDView } from './format-pane-view.js';
+/** `ST_BevelPresetType`, in PowerPoint's gallery order. */
+export declare const CHART_BEVEL_TYPES: readonly ['circle', 'relaxedInset', 'cross', 'coolSlant', 'angle', 'softRound', 'convex', 'slope', 'divot', 'riblet', 'hardEdge', 'artDeco'];
+/** The 3-D Format section for an element with `threeD` as its current 3-D settings. */
+export declare function threeDSection(threeD: ChartFormatThreeDView): ChartFormatSection;
+//# sourceMappingURL=format-pane-3d.d.ts.map

package/dist/chart/format-pane-3d.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"format-pane-3d.d.ts","sourceRoot":"","sources":["../../src/chart/format-pane-3d.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAuC,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AACnG,OAAO,KAAK,EAAwB,qBAAqB,EAAE,MAAM,oBAAoB,CAAC;AAEtF,2DAA2D;AAC3D,eAAO,MAAM,iBAAiB,YAC7B,QAAQ,EACR,cAAc,EACd,OAAO,EACP,WAAW,EACX,OAAO,EACP,WAAW,EACX,QAAQ,EACR,OAAO,EACP,OAAO,EACP,QAAQ,EACR,UAAU,EACV,SAAS,CACA,CAAC;AAwEX,uFAAuF;AACvF,wBAAgB,aAAa,CAAC,MAAM,EAAE,qBAAqB,GAAG,kBAAkB,CA+C/E"}