textmode.export.js 1.5.2 → 1.6.0-beta.2

package/dist/types/overlay/blades/Blade.d.ts

@@ -5,6 +5,11 @@ interface ManagedComponent {
     unmount(): void;
     destroy(): void;
 }
+export interface BladeCapabilities {
+    clipboard: boolean;
+    layerTarget: boolean;
+    recording: boolean;
+}
 export interface BladeConfig<TOptions> {
     label: string;
     supportsClipboard: boolean;
@@ -13,15 +18,16 @@ export interface BladeConfig<TOptions> {
     layerTargetProvider?: LayerTargetProvider;
 }
 export declare abstract class Blade<TOptions> extends Component<void> {
-    protected readonly _config: BladeConfig<TOptions>;
+    readonly capabilities: BladeCapabilities;
+    protected _config: BladeConfig<TOptions>;
     private readonly _managedComponents;
-    constructor(config: BladeConfig<TOptions>);
+    constructor(config: BladeConfig<TOptions>, capabilities?: Partial<BladeCapabilities>);
     abstract getOptions(): TOptions;
     abstract reset(): void;
     abstract validate(): boolean;
+    abstract setDefaults(values: Partial<TOptions>): void;
     protected _manageComponent<TComponent extends ManagedComponent>(component: TComponent): TComponent;
     protected _onUnmount(): void;
     protected _onDestroy(): void;
 }
 export {};
-//# sourceMappingURL=Blade.d.ts.map

package/dist/types/overlay/blades/GIFBlade.d.ts

@@ -11,6 +11,7 @@ export declare class GIFBlade extends Blade<GIFExportOptions> {
     constructor(config: BladeConfig<GIFExportOptions>);
     render(): HTMLElement;
     getOptions(): GIFExportOptions;
+    setDefaults(values: Partial<GIFExportOptions>): void;
     reset(): void;
     validate(): boolean;
     isRecording(): boolean;
@@ -20,4 +21,3 @@ export declare class GIFBlade extends Blade<GIFExportOptions> {
     private safeParseInt;
     private safeParseFloat;
 }
-//# sourceMappingURL=GIFBlade.d.ts.map

package/dist/types/overlay/blades/ImageBlade.d.ts

@@ -7,8 +7,8 @@ export declare class ImageBlade extends Blade<ImageExportOptions> {
     constructor(config: BladeConfig<ImageExportOptions>);
     render(): HTMLElement;
     getOptions(): ImageExportOptions;
+    setDefaults(values: Partial<ImageExportOptions>): void;
     reset(): void;
     validate(): boolean;
     private applyDefaults;
 }
-//# sourceMappingURL=ImageBlade.d.ts.map

package/dist/types/overlay/blades/JSONBlade.d.ts

@@ -11,10 +11,10 @@ export declare class JSONBlade extends Blade<JSONExportOptions> {
     constructor(config: BladeConfig<JSONExportOptions>);
     render(): HTMLElement;
     getOptions(): JSONExportOptions;
+    setDefaults(values: Partial<JSONExportOptions>): void;
     reset(): void;
     validate(): boolean;
     refreshLayerTargets(): void;
     private applyDefaults;
     private updateLayerTargetVisibility;
 }
-//# sourceMappingURL=JSONBlade.d.ts.map

package/dist/types/overlay/blades/RecordingBlade.d.ts

@@ -0,0 +1,7 @@
+import { Blade } from './Blade';
+export interface RecordingBladeLike {
+    isRecording(): boolean;
+    setRecordingState(state: string, progress?: unknown): void;
+    handleProgress(progress: unknown): void;
+}
+export declare function isRecordingBlade(blade: Blade<unknown>): blade is Blade<unknown> & RecordingBladeLike;

package/dist/types/overlay/blades/SVGBlade.d.ts

@@ -9,10 +9,10 @@ export declare class SVGBlade extends Blade<SVGExportOptions> {
     constructor(config: BladeConfig<SVGExportOptions>);
     render(): HTMLElement;
     getOptions(): SVGExportOptions;
+    setDefaults(values: Partial<SVGExportOptions>): void;
     reset(): void;
     validate(): boolean;
     refreshLayerTargets(): void;
     private updateStrokeControls;
     private applyDefaults;
 }
-//# sourceMappingURL=SVGBlade.d.ts.map

package/dist/types/overlay/blades/TextBlade.d.ts

@@ -8,9 +8,9 @@ export declare class TextBlade extends Blade<TXTExportOptions> {
     constructor(config: BladeConfig<TXTExportOptions>);
     render(): HTMLElement;
     getOptions(): TXTExportOptions;
+    setDefaults(values: Partial<TXTExportOptions>): void;
     reset(): void;
     validate(): boolean;
     refreshLayerTargets(): void;
     private applyDefaults;
 }
-//# sourceMappingURL=TextBlade.d.ts.map

package/dist/types/overlay/blades/VideoBlade.d.ts

@@ -16,6 +16,7 @@ export declare class VideoBlade extends Blade<VideoExportOptions> {
     constructor(config: BladeConfig<VideoExportOptions>);
     render(): HTMLElement;
     getOptions(): VideoExportOptions;
+    setDefaults(values: Partial<VideoExportOptions>): void;
     reset(): void;
     validate(): boolean;
     isRecording(): boolean;
@@ -28,4 +29,3 @@ export declare class VideoBlade extends Blade<VideoExportOptions> {
     private readonly handleFormatChange;
     private syncTransparencyAvailability;
 }
-//# sourceMappingURL=VideoBlade.d.ts.map

package/dist/types/overlay/blades/index.d.ts

@@ -1,8 +1,10 @@
 export { Blade } from './Blade';
+export type { BladeCapabilities, BladeConfig } from './Blade';
 export { TextBlade } from './TextBlade';
 export { JSONBlade } from './JSONBlade';
 export { ImageBlade } from './ImageBlade';
 export { SVGBlade } from './SVGBlade';
 export { GIFBlade } from './GIFBlade';
 export { VideoBlade } from './VideoBlade';
-//# sourceMappingURL=index.d.ts.map
+export { isRecordingBlade } from './RecordingBlade';
+export type { RecordingBladeLike } from './RecordingBlade';

package/dist/types/overlay/components/actions/Button.d.ts

@@ -16,4 +16,3 @@ export declare class Button extends Component<ButtonProps> {
     setDisabled(disabled: boolean): void;
     protected onUpdate(props: ButtonProps): void;
 }
-//# sourceMappingURL=Button.d.ts.map

package/dist/types/overlay/components/base/Component.d.ts

@@ -15,4 +15,3 @@ export declare abstract class Component<TProps = void> {
     get root(): HTMLElement;
     isMounted(): boolean;
 }
-//# sourceMappingURL=Component.d.ts.map

package/dist/types/overlay/components/base/Container.d.ts

@@ -6,4 +6,3 @@ export declare class Container extends Component<void> {
     constructor(variant?: ContainerVariant, additionalClasses?: string[]);
     render(): HTMLElement;
 }
-//# sourceMappingURL=Container.d.ts.map

package/dist/types/overlay/components/base/Field.d.ts

@@ -14,4 +14,3 @@ export declare class Field extends Component<FieldProps> {
     protected onUpdate(props: FieldProps): void;
     private applyVariant;
 }
-//# sourceMappingURL=Field.d.ts.map

package/dist/types/overlay/components/display/Header.d.ts

@@ -1,8 +1,10 @@
 import { Component } from '../base/Component';
 export declare class Header extends Component<void> {
     private static readonly _iconNamespace;
+    private _dragHandle?;
+    get dragHandleElement(): HTMLButtonElement;
     render(): HTMLElement;
+    private _createButton;
     private _createLink;
     private _createIcon;
 }
-//# sourceMappingURL=Header.d.ts.map

package/dist/types/overlay/components/display/StatusDisplay.d.ts

@@ -16,4 +16,3 @@ export declare class StatusDisplay extends Component<StatusDisplayProps> {
     protected onUpdate(props: StatusDisplayProps): void;
     private applyVariant;
 }
-//# sourceMappingURL=StatusDisplay.d.ts.map

package/dist/types/overlay/components/inputs/CheckboxInput.d.ts

@@ -17,4 +17,3 @@ export declare class CheckboxInput extends Component<CheckboxInputProps> {
     protected _onUnmount(): void;
     protected onUpdate(props: CheckboxInputProps): void;
 }
-//# sourceMappingURL=CheckboxInput.d.ts.map

package/dist/types/overlay/components/inputs/LayerTargetSelect.d.ts

@@ -17,4 +17,3 @@ export declare class LayerTargetSelect extends Component<void> {
     protected _onUnmount(): void;
     protected _onDestroy(): void;
 }
-//# sourceMappingURL=LayerTargetSelect.d.ts.map

package/dist/types/overlay/components/inputs/NumberInput.d.ts

@@ -29,4 +29,3 @@ export declare class NumberInput extends Component<NumberInputProps> {
     private updateDisplay;
     private clearHoldTimers;
 }
-//# sourceMappingURL=NumberInput.d.ts.map

package/dist/types/overlay/components/inputs/RangeInput.d.ts

@@ -32,4 +32,3 @@ export declare class RangeInput extends Component<RangeInputProps> {
     private getMax;
     private getCurrentValue;
 }
-//# sourceMappingURL=RangeInput.d.ts.map

package/dist/types/overlay/components/inputs/SelectInput.d.ts

@@ -22,4 +22,3 @@ export declare class SelectInput<TValue extends string = string> extends Compone
     update(partial: Partial<SelectInputProps<TValue>>): void;
     private populateOptions;
 }
-//# sourceMappingURL=SelectInput.d.ts.map

package/dist/types/overlay/components/inputs/TextInput.d.ts

@@ -16,4 +16,3 @@ export declare class TextInput extends Component<TextInputProps> {
     protected _onUnmount(): void;
     protected onUpdate(props: TextInputProps): void;
 }
-//# sourceMappingURL=TextInput.d.ts.map

package/dist/types/overlay/config/DefaultsStore.d.ts

@@ -0,0 +1,11 @@
+import type { ExportDefaults, ExportDefaultsPatch, ExportFormat } from '../types';
+export type ExportDefaultsResetTarget = ExportFormat | 'format';
+export declare class DefaultsStore {
+    private _defaults;
+    constructor();
+    get current(): Readonly<ExportDefaults>;
+    snapshot(): ExportDefaults;
+    get<TFormat extends ExportFormat>(format: TFormat): ExportDefaults[TFormat];
+    merge(patch: ExportDefaultsPatch): void;
+    reset(target?: ExportDefaultsResetTarget): void;
+}

package/dist/types/overlay/config/ExportDefaults.d.ts

@@ -0,0 +1,3 @@
+import type { ExportDefaults } from '../types';
+export declare const CURATED_DEFAULTS: Readonly<ExportDefaults>;
+export declare function createExportDefaults(): ExportDefaults;

package/dist/types/overlay/core/EventBus.d.ts

@@ -8,4 +8,3 @@ export declare class EventBus<TEvents extends EventMap> {
     $clear(): void;
 }
 export {};
-//# sourceMappingURL=EventBus.d.ts.map

package/dist/types/overlay/core/OverlayController.d.ts

@@ -1,12 +1,12 @@
 import type { Textmodifier } from 'textmode.js';
 import type { TextmodeExportAPI } from '../../types';
-import { EventBus } from './EventBus';
-import { StateManager } from './StateManager';
-import type { OverlayEvents } from '../models/OverlayEvents';
-import type { OverlayState } from '../models/OverlayState';
+import type { ExportDefaults, ExportDefaultsPatch } from '../types';
 import type { FormatDefinition } from '../models/FormatDefinition';
+import { type OverlayPosition } from '../services/PositionService';
+import { DefaultsStore } from '../config/DefaultsStore';
 export declare class OverlayController {
     private readonly _textmodifier;
+    private readonly _defaultsStore;
     private readonly _state;
     private readonly _events;
     private readonly _exportService;
@@ -30,15 +30,39 @@ export declare class OverlayController {
     private readonly _handleFormatSelectChange;
     private readonly _handleExportClickSafe;
     private readonly _handleCopyClickSafe;
-    constructor(textmodifier: Textmodifier, exportAPI: TextmodeExportAPI, state: StateManager<OverlayState>, events: EventBus<OverlayEvents>, definitions: ReadonlyArray<FormatDefinition>);
+    constructor(textmodifier: Textmodifier, exportAPI: TextmodeExportAPI, defaultsStore: DefaultsStore, definitions: ReadonlyArray<FormatDefinition>);
     $mount(): void;
     show(): void;
     hide(): void;
     toggle(): void;
     isVisible(): boolean;
     refreshLayerTargets(): void;
+    resetPosition(): void;
+    getPosition(): Readonly<OverlayPosition>;
+    setPosition(position: Pick<OverlayPosition, 'offsetX' | 'offsetY'>): void;
+    /**
+     * Override the curated per-format defaults at runtime.
+     *
+     * Merges the supplied patch into the internal defaults store and
+     * pushes the new values into every mounted blade.  The currently
+     * visible blade is updated immediately; other formats pick up
+     * the new defaults when the user switches to them.
+     */
+    setDefaults(patch: ExportDefaultsPatch): void;
+    /**
+     * Read the current effective defaults for every format.
+     */
+    getDefaults(): Readonly<ExportDefaults>;
+    /**
+     * Restore one or all formats to the library's curated defaults.
+     */
+    resetDefaults(target?: keyof ExportDefaults): void;
     $dispose(): void;
+    private _resetAffectedBlades;
     private _initializeFormatMap;
+    private _resolveInitialFormat;
+    private _getFormatKeys;
+    private _assertKnownFormat;
     private _createOverlay;
     private _renderStaticContent;
     private _prepareFormatOptions;
@@ -50,4 +74,3 @@ export declare class OverlayController {
     private _handleCopyClick;
     private _updateExportButton;
 }
-//# sourceMappingURL=OverlayController.d.ts.map

package/dist/types/overlay/core/StateManager.d.ts

@@ -8,4 +8,3 @@ export declare class StateManager<TState extends object> {
     $subscribe(listener: StateListener<TState>): () => void;
     $reset(state: TState): void;
 }
-//# sourceMappingURL=StateManager.d.ts.map

package/dist/types/overlay/formatRegistry.d.ts

@@ -1,5 +1,6 @@
 import type { ExportFormat } from './types';
 import type { FormatDefinition } from './models/FormatDefinition';
 import type { LayerTargetProvider } from '../exporters/base';
-export declare function getExportFormatDefinitions(layerTargetProvider?: LayerTargetProvider): ReadonlyArray<FormatDefinition<ExportFormat>>;
-//# sourceMappingURL=formatRegistry.d.ts.map
+import type { ExportDefaults } from './types';
+export type ExportDefaultsProvider = <TFormat extends ExportFormat>(format: TFormat) => ExportDefaults[TFormat];
+export declare function getExportFormatDefinitions(layerTargetProvider?: LayerTargetProvider, getDefaults?: ExportDefaultsProvider): ReadonlyArray<FormatDefinition<ExportFormat>>;

package/dist/types/overlay/index.d.ts

@@ -2,7 +2,6 @@ import type { Textmodifier } from 'textmode.js';
 import type { TextmodeExportAPI } from '../types';
 import type { LayerTargetProvider } from '../exporters/base';
 import { OverlayController } from './core/OverlayController';
-export type { ExportFormat } from './types';
 /**
  * Creates an export overlay controller.
  *
@@ -12,4 +11,3 @@ export type { ExportFormat } from './types';
  * @returns The overlay controller instance.
  */
 export declare function createExportOverlay(textmodifier: Textmodifier, exportAPI: TextmodeExportAPI, layerTargetProvider?: LayerTargetProvider): OverlayController;
-//# sourceMappingURL=index.d.ts.map

package/dist/types/overlay/models/FormatDefinition.d.ts

@@ -6,4 +6,3 @@ export interface FormatDefinition<TFormat extends ExportFormat = ExportFormat> {
     readonly supportsClipboard: boolean;
     createBlade(): Blade<ExportOptionsMap[TFormat]>;
 }
-//# sourceMappingURL=FormatDefinition.d.ts.map

package/dist/types/overlay/models/OverlayEvents.d.ts

@@ -23,4 +23,3 @@ export interface OverlayEvents extends Record<string, unknown> {
         format: ExportFormat;
     };
 }
-//# sourceMappingURL=OverlayEvents.d.ts.map

package/dist/types/overlay/models/OverlayState.d.ts

@@ -12,5 +12,4 @@ export interface OverlayState {
     videoProgress?: VideoExportProgress;
     error?: Error;
 }
-export declare const createInitialOverlayState: (defaultFormat: ExportFormat) => OverlayState;
-//# sourceMappingURL=OverlayState.d.ts.map
+export declare const createInitialOverlayState: (initialFormat: ExportFormat) => OverlayState;

package/dist/types/overlay/services/ClipboardService.d.ts

@@ -4,11 +4,7 @@ type ClipboardExportFormat = Extract<ExportFormat, 'txt' | 'json' | 'svg' | 'ima
 export declare class ClipboardService {
     private readonly api;
     constructor(api: TextmodeExportAPI);
-    $copy(format: 'txt', options: ExportOptionsMap['txt']): Promise<void>;
-    $copy(format: 'json', options: ExportOptionsMap['json']): Promise<void>;
-    $copy(format: 'svg', options: ExportOptionsMap['svg']): Promise<void>;
-    $copy(format: 'image', options: ExportOptionsMap['image']): Promise<void>;
     $copy(format: ClipboardExportFormat, options: ExportOptionsMap[ClipboardExportFormat]): Promise<void>;
+    static isClipboardFormat(format: ExportFormat): format is ClipboardExportFormat;
 }
 export {};
-//# sourceMappingURL=ClipboardService.d.ts.map

package/dist/types/overlay/services/ExportService.d.ts

@@ -13,6 +13,4 @@ export declare class ExportService {
     private readonly events;
     constructor(api: TextmodeExportAPI, events: EventBus<OverlayEvents>);
     $requestExport(format: ExportFormat, options: unknown, hooks?: ExportHooks): Promise<void>;
-    private _execute;
 }
-//# sourceMappingURL=ExportService.d.ts.map

package/dist/types/overlay/services/OverlayPositionStorage.d.ts

@@ -0,0 +1,12 @@
+export interface StoredOverlayPosition {
+    version: 1;
+    offsetX: number;
+    offsetY: number;
+}
+export declare class OverlayPositionStorage {
+    private readonly key;
+    constructor(key?: string);
+    load(): StoredOverlayPosition | undefined;
+    save(offsetX: number, offsetY: number): void;
+    clear(): void;
+}

package/dist/types/overlay/services/PositionService.d.ts

@@ -1,14 +1,44 @@
 import type { Textmodifier } from 'textmode.js';
+import { OverlayPositionStorage } from './OverlayPositionStorage';
+export interface OverlayPosition {
+    mode: 'auto' | 'custom';
+    offsetX: number;
+    offsetY: number;
+}
+interface SetPositionOptions {
+    persist?: boolean;
+}
 export declare class PositionService {
     private readonly modifier;
-    private readonly overlay;
+    private readonly host;
+    private readonly surface;
+    private readonly storage;
     private animationFrameId;
     private readonly handleUpdate;
     private bound;
-    constructor(modifier: Textmodifier, overlay: HTMLElement);
+    private dragHandle?;
+    private dragState?;
+    private position;
+    private renderedOffset;
+    private readonly handlePointerDown;
+    private readonly handlePointerMove;
+    private readonly handlePointerUp;
+    private readonly handleKeyDown;
+    constructor(modifier: Textmodifier, host: HTMLElement, surface?: HTMLElement, storage?: OverlayPositionStorage);
+    getPosition(): Readonly<OverlayPosition>;
+    setPosition(position: Pick<OverlayPosition, 'offsetX' | 'offsetY'>, options?: SetPositionOptions): void;
+    resetPosition(): void;
     scheduleUpdate(): void;
     bind(): void;
+    attachDragHandle(handle: HTMLElement): void;
+    private detachDragHandle;
+    private onPointerDown;
+    private onPointerMove;
+    private onPointerUp;
+    private onKeyDown;
     private update;
+    private clampToViewport;
+    private clamp;
     dispose(): void;
 }
-//# sourceMappingURL=PositionService.d.ts.map
+export {};

package/dist/types/overlay/types.d.ts

@@ -2,7 +2,7 @@ import type { ImageExportOptions } from '../exporters/image';
 import type { TXTExportOptions } from '../exporters/txt';
 import type { SVGExportOptions } from '../exporters/svg';
 import type { GIFExportOptions } from '../exporters/gif';
-import type { VideoExportOptions } from '../exporters/video';
+import type { VideoBitratePreset, VideoExportOptions } from '../exporters/video';
 import type { JSONExportOptions } from '../exporters/json';
 export type ExportFormat = 'txt' | 'json' | 'image' | 'gif' | 'video' | 'svg';
 export type ExportOptionsMap = {
@@ -13,4 +13,38 @@ export type ExportOptionsMap = {
     video: VideoExportOptions;
     svg: SVGExportOptions;
 };
-//# sourceMappingURL=types.d.ts.map
+export type TXTOverlayDefaults = Pick<TXTExportOptions, 'preserveTrailingSpaces' | 'emptyCharacter'>;
+export type JSONOverlayDefaults = Pick<JSONExportOptions, 'target' | 'pretty' | 'includeMetadata' | 'colorMode'>;
+export type ImageOverlayDefaults = Pick<ImageExportOptions, 'format' | 'scale'>;
+export type SVGOverlayDefaults = Pick<SVGExportOptions, 'includeBackgroundRectangles' | 'drawMode' | 'strokeWidth'>;
+export type GIFOverlayDefaults = Pick<GIFExportOptions, 'frameCount' | 'frameRate' | 'scale' | 'repeat'>;
+export type VideoOverlayDefaults = Pick<VideoExportOptions, 'format' | 'frameCount' | 'frameRate' | 'bitrateMode' | 'latencyMode' | 'hardwareAcceleration' | 'keyFrameInterval' | 'transparent'> & {
+    bitrate?: VideoBitratePreset;
+};
+/**
+ * Curated default options for every export format.
+ *
+ * Each sub-object contains the library-chosen default values for the fields
+ * that the overlay exposes as inputs.  These are the values applied when the
+ * overlay first mounts and after a {@link OverlayController.resetDefaults}.
+ */
+export type ExportDefaults = {
+    format: ExportFormat;
+    txt: TXTOverlayDefaults;
+    json: JSONOverlayDefaults;
+    image: ImageOverlayDefaults;
+    svg: SVGOverlayDefaults;
+    gif: GIFOverlayDefaults;
+    video: VideoOverlayDefaults;
+};
+/**
+ * Partial patch accepted by {@link OverlayController.setDefaults}.
+ *
+ * Every supplied sub-object is deep-merged into the corresponding format's
+ * curated defaults.  Omitted keys keep their current value.
+ */
+export type ExportDefaultsPatch = {
+    format?: ExportFormat;
+} & {
+    [K in ExportFormat]?: Partial<ExportDefaults[K]>;
+};

package/dist/types/overlay/utils/classes.d.ts

@@ -6,7 +6,10 @@ export declare const overlayClasses: {
     readonly section: "textmode-export-overlay__section";
     readonly header: "textmode-export-overlay__header";
     readonly headerTitleRow: "textmode-export-overlay__header-title-row";
+    readonly headerIdentity: "textmode-export-overlay__header-identity";
     readonly headerLinks: "textmode-export-overlay__header-links";
+    readonly grabHandle: "textmode-export-overlay__grab-handle";
+    readonly rootDragging: "textmode-export-overlay--dragging";
     readonly row: "textmode-export-overlay__row";
     readonly label: "textmode-export-overlay__label";
     readonly field: "textmode-export-overlay__field";
@@ -32,4 +35,3 @@ export declare const overlayClasses: {
     readonly supportIcon: "textmode-export-overlay__support-icon";
     readonly linkIcon: "textmode-export-overlay__link-icon";
 };
-//# sourceMappingURL=classes.d.ts.map