@trebco/treb 36.1.4 → 37.0.1

package/build/treb-format/src/format.d.ts

@@ -0,0 +1,130 @@
+import { NumberFormatSection } from './number_format_section';
+import type { TextPart, Complex, DimensionedQuantity, CellValue } from 'treb-base-types';
+/** convert cell value -> date, using the rules above */
+export declare const LotusDate: (value: number) => Date;
+/** convert date (as number, utc millis) -> lotus date value */
+export declare const UnlotusDate: (value: number, local?: boolean) => number;
+/**
+ * unifying date format and number format (really just bolting dates
+ * on the side). dates have only a single section, constant pattern, and
+ * are immutable.
+ */
+export declare class NumberFormat {
+    static grouping_regexp: RegExp;
+    static fraction_limits: number[];
+    /**
+     * this is now exposed so it can be changed, for rendering; some options are
+     *
+     * "i" - regular i, and the default
+     * "𝑖" - mathematical italic small i", U+1D456
+     * " 𝑖" - the same, with a leading hair space (U+200A)
+     */
+    static imaginary_character: string;
+    /**
+     * also for complex rendering, the minus sign. there's a unicode
+     * symbol U+2212 which (at least in calibri) is wider than the regular minus
+     * sign/hyphen. I like this but it looks a bit odd if negative numbers are
+     * rendered using the other one.
+     *
+     * "-" - hyphen
+     * "−" - minus
+     */
+    static minus_character: string;
+    /**
+     * (testing) transformer. this is not rendered or persisted, like magic
+     * decimal it needs to be applied in code. ATM this is only applied in
+     * formatting DQ, but it might turn out to be more universal...
+     *
+     * NOTE that atm this transforms value back into the same type; we don't
+     * cross types (at least for now). perhaps we should support that? that
+     * might mean switching in here and removing the "special" format calls
+     * for complex and DQ.
+     */
+    transform_value?: (value: CellValue) => CellValue;
+    protected _pattern: string;
+    protected sections: NumberFormatSection[];
+    protected decimal_zero_regexp: Array<RegExp | undefined>;
+    protected cloned: boolean[];
+    get pattern(): string;
+    /** flag indicates if this is a date format */
+    get date_format(): boolean;
+    constructor(pattern: string);
+    /**
+     * render text parts to string
+     * FIXME: move
+     */
+    static FormatPartsAsText(parts: TextPart[], text_width?: number): string;
+    /** for decimal only, set an explicit number of digits */
+    SetDecimal(digits: number): void;
+    /**
+     * mutate
+     * UPDATE: for fractional formats, increase the denominator digits
+     *         (doing something weird with fixed denominators...)
+     */
+    IncreaseDecimal(): void;
+    /**
+     * mutate
+     * UPDATE: for fractional formats, decrease the denominator digits
+     *         (doing something weird with fixed denominators...)
+     */
+    DecreaseDecimal(): void;
+    /** mutate */
+    AddGrouping(): void;
+    /** mutate */
+    RemoveGrouping(): void;
+    /** mutate */
+    ToggleGrouping(): void;
+    /**
+     * generates a string representation. we use this because we are (now)
+     * allowing mutation of formats; therefore we need to serialize them back
+     * to the basic format.
+     */
+    toString(): string;
+    /** also temporary? why not switch in here? */
+    FormatDimensionedQuantity(value: DimensionedQuantity): TextPart[] | string;
+    /**
+     * temporary
+     *
+     * FIXME: merge with FormatParts, use a test to check if it's complex?
+     * OTOH that adds a test to every format which is probably wasteful...
+     * although we can check for 'number' first
+     *
+     */
+    FormatComplex(value: Complex): TextPart[];
+    /**
+     * this method composes the format as a set of parts with various
+     * states. it's intended for graphical representation where things
+     * like hidden characters and padding require multiple passes or measurement.
+     */
+    FormatParts(value: CellValue): TextPart[];
+    /**
+     * formats a number as text.
+     *
+     * this method will use a single space to replace hidden (leading-underscore)
+     * characters. if a text width is provided, it will use that for padding;
+     * otherwise the padding character (we only allow a single padding character)
+     * is rendered once.
+     *
+     * FIXME: date, string (this is lagging)
+     * UPDATE: unifying, basing this on the text part functionality
+     */
+    Format(value: CellValue, text_width?: number): string;
+    ZeroPad(text: string, length: number): string;
+    DateFormat(value: number): {
+        parts: TextPart[];
+        section: NumberFormatSection;
+    };
+    StringFormat(value: string, section: NumberFormatSection): {
+        parts: TextPart[];
+        section: NumberFormatSection;
+    };
+    Round2(value: number, digits: number): number;
+    FormatFraction(value: number, section: NumberFormatSection): string;
+    BaseFormat(value: CellValue): {
+        parts: TextPart[];
+        section: NumberFormatSection;
+    } | {
+        parts: string[];
+        section: NumberFormatSection;
+    };
+}