@openreachtech/furo-vue 1.3.1

package/types/generated/components/molecules/FuroEditableField/FuroEditableFieldContext.d.ts

@@ -0,0 +1,477 @@
+/**
+ * Context class for managing FuroEditableField component.
+ *
+ * @extends {BaseFuroContext<null, Props, EmitEventName>}
+ */
+export default class FuroEditableFieldContext extends BaseFuroContext<null, Props, EmitEventName> {
+    /**
+     * Factory method.
+     *
+     * @template {X extends typeof FuroEditableFieldContext ? X : never} T, X
+     * @override
+     * @param {FuroEditableFieldContextFactoryParams} params - Parameters of this factory method.
+     * @returns {InstanceType<T>} An instance of this class.
+     * @this {T}
+     */
+    static override create<T extends X extends typeof FuroEditableFieldContext ? X : never, X>(this: T, { props, componentContext, refHash, reactiveHash, }: FuroEditableFieldContextFactoryParams): InstanceType<T>;
+    /**
+     * Build ref hash.
+     *
+     * @override
+     */
+    static override buildRefHash(): {
+        originalValueRef: import("vue").Ref<any, any>;
+        committedValueRef: import("vue").Ref<any, any>;
+        draftValueRef: import("vue").Ref<any, any>;
+        editableRootInstanceRef: import("vue").Ref<any, any>;
+        anchorElementRef: import("vue").Ref<any, any>;
+        floatingEditorElementRef: import("vue").Ref<any, any>;
+        scrollEventListenerRef: import("vue").Ref<any, any>;
+        resizeEventListenerRef: import("vue").Ref<any, any>;
+        editorPositionRevisionRef: import("vue").Ref<number, number>;
+    };
+    /**
+     * Build reactive hash.
+     *
+     * @override
+     */
+    static override buildReactiveHash(): {
+        statusReactive: {
+            isShowEditing: boolean;
+        };
+    };
+    /**
+     * Get emit event name.
+     *
+     * @override
+     * @returns {Readonly<{
+     *   COMMIT_VALUE: 'commit-value'
+     *   UPDATE_EDITING_STATE: 'update-editing-state'
+     * }>}
+     */
+    static override get EMIT_EVENT_NAME(): Readonly<{
+        COMMIT_VALUE: "commit-value";
+        UPDATE_EDITING_STATE: "update-editing-state";
+    }>;
+    /**
+     * Get emit options.
+     *
+     * @returns {{
+     *   'commit-value': (payload: import('./EditableEmitPayload.js').default) => void
+     *   'update-editing-state': (editingState: EdittingState) => void
+     * }}
+     */
+    static get EMIT_EVENT_HASH(): {
+        "commit-value": (payload: import("./EditableEmitPayload.js").default) => void;
+        "update-editing-state": (editingState: EdittingState) => void;
+    };
+    /**
+     * get: Constructor of `EmitPayload`
+     *
+     * @returns {typeof EditableEmitPayload}
+     */
+    static get EmitPayloadCtor(): typeof EditableEmitPayload;
+    /**
+     * get: Constructor of `ObjectProcessor`.
+     *
+     * @returns {typeof ObjectProcessor}
+     */
+    static get ObjectProcessorCtor(): typeof ObjectProcessor;
+    /**
+     * get: Constructor of `EditorCollisionProcessor`.
+     *
+     * @returns {typeof EditorCollisionProcessor}
+     */
+    static get EditorCollisionProcessorCtor(): typeof EditorCollisionProcessor;
+    /**
+     * Constructor.
+     *
+     * @param {FuroEditableFieldContextParams} params
+     */
+    constructor({ props, componentContext, refHash, reactiveHash, }: FuroEditableFieldContextParams);
+    refHash: RefHash;
+    reactiveHash: ReactiveHash;
+    /**
+     * get: Constructor of this class.
+     *
+     * @override
+     * @returns {typeof FuroEditableFieldContext}
+     */
+    override get Ctor(): typeof FuroEditableFieldContext;
+    /**
+     * @returns {import('vue').Ref<FuroEditableValue>}
+     */
+    get originalValueRef(): import("vue").Ref<FuroEditableValue>;
+    /**
+     * @returns {import('vue').Ref<FuroEditableValue>}
+     */
+    get committedValueRef(): import("vue").Ref<FuroEditableValue>;
+    /**
+     * @returns {import('vue').Ref<FuroEditableValue>}
+     */
+    get draftValueRef(): import("vue").Ref<FuroEditableValue>;
+    /**
+     * @returns {import('vue').Ref<EditableRootMethods | null>}
+     */
+    get editableRootInstanceRef(): import("vue").Ref<EditableRootMethods | null>;
+    /**
+     * @returns {import('vue').Ref<HTMLElement | null>}
+     */
+    get anchorElementRef(): import("vue").Ref<HTMLElement | null>;
+    /**
+     * @returns {import('vue').Ref<HTMLElement | null>}
+     */
+    get floatingEditorElementRef(): import("vue").Ref<HTMLElement | null>;
+    /**
+     * @returns {import('vue').Ref<EventListener | null>}
+     */
+    get scrollEventListenerRef(): import("vue").Ref<EventListener | null>;
+    /**
+     * @returns {import('vue').Ref<EventListener | null>}
+     */
+    get resizeEventListenerRef(): import("vue").Ref<EventListener | null>;
+    /**
+     * @returns {import('vue').Ref<number>}
+     */
+    get editorPositionRevisionRef(): import("vue").Ref<number>;
+    /**
+     * @returns {StatusReactive}
+     */
+    get statusReactive(): StatusReactive;
+    /**
+     * Parcel passed from parent via props (merged defaults).
+     *
+     * @override
+     * @returns {FuroEditableFieldParcel}
+     */
+    override get parcel(): FuroEditableFieldParcel;
+    /**
+     * Setup component context.
+     *
+     * @template {X extends FuroEditableFieldContext ? X : never} T, X
+     * @override
+     * @returns {T} - For method chaining.
+     * @this {T}
+     */
+    override setupComponent<T extends X extends FuroEditableFieldContext ? X : never, X>(this: T): T;
+    /**
+     * Cancel editing on scroll.
+     *
+     * @param {{
+     *   scrollEvent: Event
+     * }} params - Parameters.
+     */
+    cancelEditingOnScroll({ scrollEvent, }: {
+        scrollEvent: Event;
+    }): void;
+    /**
+     * Setup scroll listener while editing.
+     */
+    setupEditingScrollListener(): void;
+    /**
+     * Teardown scroll listener while editing.
+     */
+    teardownEditingScrollListener(): void;
+    /**
+     * Setup resize listener while editing.
+     */
+    setupEditingResizeListener(): void;
+    /**
+     * Teardown resize listener while editing.
+     */
+    teardownEditingResizeListener(): void;
+    /**
+     * Increment editor position revision to trigger style recalculation.
+     */
+    incrementEditorPositionRevision(): void;
+    /**
+     * Schedule editor position revision after layout is ready.
+     */
+    scheduleEditorPositionRevision(): void;
+    /**
+     * Whether action triggers are shown.
+     *
+     * @returns {boolean}
+     */
+    shouldShowActionButtons(): boolean;
+    /**
+     * Whether the field is invalid.
+     *
+     * @returns {boolean}
+     */
+    isInvalid(): boolean;
+    /**
+     * Whether the field is disabled.
+     *
+     * @returns {boolean}
+     */
+    isDisabled(): boolean;
+    /**
+     * Whether the field is readonly.
+     *
+     * @returns {boolean}
+     */
+    isReadonly(): boolean;
+    /**
+     * Whether the field is required.
+     *
+     * @returns {boolean}
+     */
+    isRequired(): boolean;
+    /**
+     * Extract the accessible name of the edit trigger.
+     *
+     * @returns {string}
+     */
+    extractEditLabel(): string;
+    /**
+     * Extract the accessible name of the undo control.
+     *
+     * @returns {string}
+     */
+    extractUndoLabel(): string;
+    /**
+     * Extract the accessible name of the submit control.
+     *
+     * @returns {string}
+     */
+    extractSubmitLabel(): string;
+    /**
+     * Extract the accessible name of the cancel control.
+     *
+     * @returns {string}
+     */
+    extractCancelLabel(): string;
+    /**
+     * Extract placeholder forwarded to Reka EditableRoot.
+     *
+     * @returns {FuroEditableFieldParcel['placeholder']}
+     */
+    extractPlaceholder(): FuroEditableFieldParcel["placeholder"];
+    /**
+     * Extract root attributes forwarded to Reka EditableRoot.
+     *
+     * @returns {Props['parcel']}
+     */
+    extractRootAttributes(): Props["parcel"];
+    /**
+     * Whether the value is empty.
+     *
+     * @returns {boolean}
+     */
+    hasEmptyValue(): boolean;
+    /**
+     * Resolve preview label text.
+     *
+     * @returns {string}
+     */
+    resolvePreviewText(): string;
+    /**
+     * Build custom event.
+     *
+     * @param {{
+     *   name?: string
+     *   value?: FuroEditableValue
+     * }} [params] - Parameters.
+     * @returns {import('./EditableEmitPayload.js').EditableRawEvent}
+     */
+    buildCustomEvent({ name, value, }?: {
+        name?: string;
+        value?: FuroEditableValue;
+    }): import("./EditableEmitPayload.js").EditableRawEvent;
+    /**
+     * Build payload.
+     *
+     * @param {{
+     *   rawEvent?: import('./EditableEmitPayload.js').EditableRawEvent
+     * }} [params] - Parameters.
+     * @returns {InstanceType<typeof EditableEmitPayload>}
+     */
+    buildEmitPayload({ rawEvent, }?: {
+        rawEvent?: import("./EditableEmitPayload.js").EditableRawEvent;
+    }): InstanceType<typeof EditableEmitPayload>;
+    /**
+     * Respond to submit committed value event (blur / enter dismiss).
+     *
+     * @param {{
+     *   value?: FuroEditableValue
+     * }} [params] - Parameters.
+     * @throws {Error} When not implemented.
+     */
+    onSubmitCommittedValue({ value, }?: {
+        value?: FuroEditableValue;
+    }): void;
+    /**
+     * Respond to Reka update state event.
+     *
+     * @param {{
+     *   editingState: EdittingState
+     * }} params - Parameters.
+     * @throws {Error} When not implemented.
+     */
+    onUpdateEditingState({ editingState, }: {
+        editingState: EdittingState;
+    }): void;
+    /**
+     * Update internal value.
+     *
+     * @param {{
+     *     value: FuroEditableValue
+     *  }} params - Parameters.
+     */
+    updateDraftValue({ value, }: {
+        value: FuroEditableValue;
+    }): void;
+    /**
+     * Build slot props.
+     *
+     * @param {{
+     *   defaultSlotProps: DefaultEditableRootSlotProps
+     * }} params - Parameters.
+     * @returns {FuroEditableSlotProps}
+     */
+    buildSlotProps({ defaultSlotProps, }: {
+        defaultSlotProps: DefaultEditableRootSlotProps;
+    }): FuroEditableSlotProps;
+    /**
+     * Extract editor position elements.
+     *
+     * @returns {{
+     *   anchorElement: HTMLElement
+     *   floatingEditorElement: HTMLElement
+     * } | null}
+     */
+    extractEditorPositionElements(): {
+        anchorElement: HTMLElement;
+        floatingEditorElement: HTMLElement;
+    } | null;
+    /**
+     * Extract collision boundary element.
+     *
+     * @returns {HTMLElement | null}
+     */
+    extractCollisionBoundaryElement(): HTMLElement | null;
+    /**
+     * Generate editor style.
+     *
+     * @returns {import('vue').CSSProperties}
+     */
+    generateEditorPositionStyle(): import("vue").CSSProperties;
+    /**
+     * Build editor position style.
+     *
+     * @param {{
+     *   editorPositionRevision: number
+     * }} params - Parameters.
+     * @returns {import('vue').CSSProperties}
+     */
+    buildEditorPositionStyle({ editorPositionRevision, }: {
+        editorPositionRevision: number;
+    }): import("vue").CSSProperties;
+    /**
+     * Whether the original value has changed.
+     *
+     * @returns {boolean}
+     */
+    hasOriginalValueChanged(): boolean;
+    /**
+     * Undo change.
+     */
+    onUndoChange(): void;
+    /**
+     * Whether the undo change button should be shown.
+     *
+     * @returns {boolean}
+     */
+    shouldShowUndoChange(): boolean;
+}
+export type EmitEventName = "commit-value" | "update:value" | "update:state";
+export type FuroEditableValue = any;
+export type FuroEditableFieldParcel = {
+    value?: FuroEditableValue;
+    invalid?: boolean;
+    disabled?: boolean;
+    required?: boolean;
+    readonly?: boolean;
+    placeholder?: string;
+    emptyPreviewText?: string;
+    showActions?: boolean;
+    showEditing?: boolean;
+    showUndoChange?: boolean;
+    submitMode?: "blur" | "enter" | "both" | "none";
+    activationMode?: "dblclick" | "focus" | "none";
+    collisionBoundary?: import("vue").Ref<HTMLElement | null> | HTMLElement | null;
+    editLabel?: string;
+    undoLabel?: string;
+    submitLabel?: string;
+    cancelLabel?: string;
+};
+export type Props = {
+    parcel?: (FuroEditableFieldParcel & import("vue").Attrs) | null;
+};
+export type StatusReactive = {
+    isShowEditing: boolean;
+};
+export type ReactiveHash = {
+    statusReactive: StatusReactive;
+};
+export type EditableRootMethods = {
+    submit: () => void;
+    cancel: () => void;
+    edit: () => void;
+};
+export type RefHash = {
+    originalValueRef: import("vue").Ref<FuroEditableValue>;
+    committedValueRef: import("vue").Ref<FuroEditableValue>;
+    draftValueRef: import("vue").Ref<FuroEditableValue>;
+    editableRootInstanceRef: import("vue").Ref<EditableRootMethods | null>;
+    anchorElementRef: import("vue").Ref<HTMLElement | null>;
+    floatingEditorElementRef: import("vue").Ref<HTMLElement | null>;
+    scrollEventListenerRef: import("vue").Ref<EventListener | null>;
+    resizeEventListenerRef: import("vue").Ref<EventListener | null>;
+    editorPositionRevisionRef: import("vue").Ref<number>;
+};
+export type FuroEditableFieldContextParams = import("../../../contexts/BaseFuroContext.js").BaseFuroContextParams & {
+    props: Props;
+    componentContext: ComponentContext;
+    refHash: RefHash;
+    reactiveHash: ReactiveHash;
+};
+export type FuroEditableFieldContextFactoryParams = Omit<FuroEditableFieldContextParams, "refHash" | "reactiveHash"> & {
+    refHash?: FuroEditableFieldContextParams["refHash"];
+    reactiveHash?: FuroEditableFieldContextParams["reactiveHash"];
+};
+export type EdittingState = "cancel" | "submit" | "edit";
+export type FuroEditableFieldEmitHash = typeof FuroEditableFieldContext.EMIT_EVENT_HASH;
+export type DefaultEditableRootSlotProps = {
+    isEditing: boolean;
+    modelValue: string | null | undefined;
+    isEmpty: boolean;
+    submit: () => void;
+    cancel: () => void;
+    edit: () => void;
+};
+export type FuroEditableSlotProps = DefaultEditableRootSlotProps & {
+    committedValue: FuroEditableValue;
+    draftValue: FuroEditableValue;
+    updateDraftValue: ({ value }: {
+        value: FuroEditableValue;
+    }) => void;
+    undoChange: () => void;
+};
+export type FuroEditableFieldSlots = import("vue").SlotsType<{
+    preview: FuroEditableSlotProps;
+    editor: FuroEditableSlotProps;
+    "edit-trigger": FuroEditableSlotProps;
+    "submit-trigger": FuroEditableSlotProps;
+    "cancel-trigger": FuroEditableSlotProps;
+    "undo-trigger": FuroEditableSlotProps;
+}>;
+export type ComponentContext = import("vue").SetupContext<FuroEditableFieldEmitHash, FuroEditableFieldSlots>;
+export type FuroEditableFieldSetup = (props: Props, componentContext: ComponentContext) => {
+    context: FuroEditableFieldContext;
+};
+import BaseFuroContext from '../../../contexts/BaseFuroContext.js';
+import EditableEmitPayload from './EditableEmitPayload.js';
+import ObjectProcessor from './processors/ObjectProcessor.js';
+import EditorCollisionProcessor from './processors/EditorCollisionProcessor.js';

package/types/generated/components/molecules/FuroEditableField/processors/EditorCollisionProcessor.d.ts

@@ -0,0 +1,121 @@
+/**
+ * Processor for calculating floating editor position within a collision boundary.
+ */
+export default class EditorCollisionProcessor {
+    /**
+     * Factory method.
+     *
+     * @template {X extends typeof EditorCollisionProcessor ? X : never} T, X
+     * @param {EditorCollisionProcessorFactoryParams} params - Parameters.
+     * @returns {InstanceType<T>}
+     * @this {T}
+     */
+    static create<T extends X extends typeof EditorCollisionProcessor ? X : never, X>(this: T, { anchorRect, boundaryRect, editorWidth, editorHeight, }: EditorCollisionProcessorFactoryParams): InstanceType<T>;
+    /**
+     * Extract viewport collision boundary edges.
+     *
+     * @returns {CollisionBoundaryEdges}
+     */
+    static extractViewportCollisionBoundaryEdges(): CollisionBoundaryEdges;
+    /**
+     * Extract collision boundary edges.
+     *
+     * @param {{
+     *   boundaryRect?: DOMRect
+     * }} params - Parameters.
+     * @returns {CollisionBoundaryEdges}
+     */
+    static extractCollisionBoundaryEdges({ boundaryRect, }: {
+        boundaryRect?: DOMRect;
+    }): CollisionBoundaryEdges;
+    /**
+     * Normalize editor offset within boundary range.
+     *
+     * @param {{
+     *   preferredOffset: number
+     *   boundaryStart: number
+     *   boundaryEnd: number
+     *   editorSize: number
+     * }} params - Parameters.
+     * @returns {number}
+     */
+    static normalizeEditorOffsetWithinBoundary({ preferredOffset, boundaryStart, boundaryEnd, editorSize, }: {
+        preferredOffset: number;
+        boundaryStart: number;
+        boundaryEnd: number;
+        editorSize: number;
+    }): number;
+    /**
+     * Constructor.
+     *
+     * @param {EditorCollisionProcessorParams} params - Parameters.
+     */
+    constructor({ anchorRect, boundaryRect, editorWidth, editorHeight, }: EditorCollisionProcessorParams);
+    anchorRect: DOMRect;
+    boundaryRect: DOMRect;
+    editorWidth: number;
+    editorHeight: number;
+    /**
+     * Extract collision boundary edges for this processor.
+     *
+     * @returns {CollisionBoundaryEdges}
+     */
+    extractCollisionBoundaryEdges(): CollisionBoundaryEdges;
+    /**
+     * Calculate editor left offset.
+     *
+     * @param {{
+     *   leftBoundary: number
+     *   rightBoundary: number
+     * }} params - Parameters.
+     * @returns {string}
+     */
+    calculateEditorLeftOffset({ leftBoundary, rightBoundary, }: {
+        leftBoundary: number;
+        rightBoundary: number;
+    }): string;
+    /**
+     * Calculate editor top offset.
+     *
+     * @param {{
+     *   topBoundary: number
+     *   bottomBoundary: number
+     * }} params - Parameters.
+     * @returns {string}
+     */
+    calculateEditorTopOffset({ topBoundary, bottomBoundary, }: {
+        topBoundary: number;
+        bottomBoundary: number;
+    }): string;
+    /**
+     * Generate editor position style.
+     *
+     * @returns {{
+     *   position: 'fixed'
+     *   top: string
+     *   left: string
+     *   width: string
+     *   zIndex: string
+     * }}
+     */
+    generateEditorPositionStyle(): {
+        position: "fixed";
+        top: string;
+        left: string;
+        width: string;
+        zIndex: string;
+    };
+}
+export type CollisionBoundaryEdges = {
+    leftBoundary: number;
+    rightBoundary: number;
+    topBoundary: number;
+    bottomBoundary: number;
+};
+export type EditorCollisionProcessorParams = {
+    anchorRect: DOMRect;
+    boundaryRect?: DOMRect;
+    editorWidth: number;
+    editorHeight: number;
+};
+export type EditorCollisionProcessorFactoryParams = EditorCollisionProcessorParams;

package/types/generated/components/molecules/FuroEditableField/processors/ObjectProcessor.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Processor for comparing two values with deep equality semantics.
+ */
+export default class ObjectProcessor {
+    /**
+     * Factory method.
+     *
+     * @template {X extends typeof ObjectProcessor ? X : never} T, X
+     * @param {ObjectProcessorFactoryParams} params - Parameters.
+     * @returns {InstanceType<T>}
+     * @this {T}
+     */
+    static create<T extends X extends typeof ObjectProcessor ? X : never, X>(this: T, { leftValue, rightValue, }: ObjectProcessorFactoryParams): InstanceType<T>;
+    /**
+     * Constructor.
+     *
+     * @param {ObjectProcessorParams} params - Parameters.
+     */
+    constructor({ leftValue, rightValue, }: ObjectProcessorParams);
+    leftValue: unknown;
+    rightValue: unknown;
+    /**
+     * Whether left and right values are deeply equal.
+     *
+     * @returns {boolean}
+     */
+    areDeepEqual(): boolean;
+    /**
+     * Whether both values are non-null objects.
+     *
+     * @returns {boolean}
+     */
+    areBothObjects(): boolean;
+    /**
+     * Whether both objects have the same entries with deep equality.
+     *
+     * @returns {boolean}
+     */
+    haveSameDeepObjectEntries(): boolean;
+}
+export type ObjectProcessorParams = {
+    leftValue: unknown;
+    rightValue: unknown;
+};
+export type ObjectProcessorFactoryParams = ObjectProcessorParams;

package/types/generated/components/molecules/FuroEmptyState/FuroEmptyState.vue.d.ts

@@ -0,0 +1,21 @@
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: import("vue").DefineComponent<{
+    parcel: {
+        title?: string;
+        description?: string;
+    } | null;
+}, {
+    context: FuroEmptyStateContext;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{
+    parcel: {
+        title?: string;
+        description?: string;
+    } | null;
+}> & Readonly<{}>, {
+    parcel: {
+        title?: string;
+        description?: string;
+    };
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+import FuroEmptyStateContext from './FuroEmptyStateContext.js';

package/types/generated/components/molecules/FuroEmptyState/FuroEmptyStateContext.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Context class for FuroEmptyState molecule.
+ *
+ * Presentational placeholder shown when a region has no content to display
+ * (no views, no records, nothing found). Title and description text come from
+ * the parcel so the consumer owns the wording; an icon and action controls are
+ * supplied via slots. It carries no value and emits nothing.
+ *
+ * @extends {BaseFuroContext<null, Props, null>}
+ */
+export default class FuroEmptyStateContext extends BaseFuroContext<null, Props, null> {
+    constructor({ props, componentContext, reactiveHash, refHash, shallowRefHash, modelRefHash, }: import("../../../contexts/BaseFuroContext.js").BaseFuroContextParams<Props, null, {}, {}, {}, {}>);
+    /**
+     * get: heading text.
+     *
+     * @returns {string | null} Title, or null when the consumer supplies none.
+     */
+    get title(): string | null;
+    /**
+     * get: supporting description text.
+     *
+     * @returns {string | null} Description, or null when the consumer supplies none.
+     */
+    get description(): string | null;
+}
+export type Props = {
+    parcel: {
+        title?: string;
+        description?: string;
+    } | null;
+};
+import BaseFuroContext from '../../../contexts/BaseFuroContext.js';