@trebco/treb 36.1.4 → 37.0.1

package/build/treb-data-model/src/conditional_format.d.ts

@@ -0,0 +1,155 @@
+import type { CellStyle, EvaluateOptions, IArea, Color, Gradient, GradientStop, UnionValue } from 'treb-base-types';
+interface VertexPlaceholder {
+    result: UnionValue;
+    updated: boolean;
+}
+export interface CondifionalFormatExpressionOptions {
+    style: CellStyle;
+    expression: string;
+    options?: EvaluateOptions;
+}
+/**
+ * conditional format predicated on an expression. if the expression
+ * evaluates to true, we apply the style. otherwise no.
+ */
+export interface ConditionalFormatExpression extends CondifionalFormatExpressionOptions {
+    type: 'expression';
+    area: IArea;
+    /** @internal */
+    internal?: {
+        vertex?: VertexPlaceholder;
+    };
+}
+export interface ConditionalFormatGradientOptions {
+    /** property defaults to fill */
+    property?: 'fill' | 'text';
+    /** defaults to RGB */
+    color_space?: 'HSL' | 'RGB';
+    /** gradient stops, required */
+    stops: Array<{
+        value: number;
+        color: Color;
+    }>;
+    /** min and max are optional. if not provided, we use the min/max of the range of data. */
+    min?: number;
+    /** min and max are optional. if not provided, we use the min/max of the range of data. */
+    max?: number;
+}
+/**
+ *
+ * @internal
+ *
+ * @privateRemarks
+ *
+ * this is marked internal temporarily while I figure out why our API
+ * generator is not exporting the gradient stop type
+ */
+export declare const StandardGradientsList: {
+    readonly 'red-green': {
+        readonly color_space: "RGB";
+        readonly stops: GradientStop[];
+    };
+    readonly 'red-yellow-green': {
+        readonly color_space: "RGB";
+        readonly stops: GradientStop[];
+    };
+    readonly 'green-red': {
+        readonly color_space: "RGB";
+        readonly stops: GradientStop[];
+    };
+    readonly 'green-yellow-red': {
+        readonly color_space: "RGB";
+        readonly stops: GradientStop[];
+    };
+};
+export type StandardGradient = 'red-green' | 'green-red' | 'red-yellow-green' | 'green-yellow-red';
+export interface ConditionalFormatGradient extends ConditionalFormatGradientOptions {
+    type: 'gradient';
+    area: IArea;
+    /** @internal */
+    internal?: {
+        gradient?: Gradient;
+        vertex?: VertexPlaceholder;
+    };
+}
+export interface ConditionalFormatDataBarOptions {
+    /** min and max are optional. if not provided, we use the min/max of the range of data. */
+    min?: number;
+    /** min and max are optional. if not provided, we use the min/max of the range of data. */
+    max?: number;
+    /** */
+    fill: Color;
+    /** */
+    negative?: Color;
+    /** */
+    hide_values?: boolean;
+}
+export interface ConditionalFormatDataBar extends ConditionalFormatDataBarOptions {
+    type: 'data-bar';
+    area: IArea;
+    /** @internal */
+    internal?: {
+        vertex?: VertexPlaceholder;
+    };
+}
+export interface ConditionalFormatCellMatchOptions {
+    style: CellStyle;
+    expression: string;
+    options?: EvaluateOptions;
+}
+export interface ConditionalFormatCellMatch extends ConditionalFormatCellMatchOptions {
+    type: 'cell-match';
+    area: IArea;
+    /** @internal */
+    internal?: {
+        vertex?: VertexPlaceholder;
+    };
+}
+export interface ConditionalFormatCellMatchOptions {
+    style: CellStyle;
+    expression: string;
+    between?: [number, number];
+    options?: EvaluateOptions;
+}
+export interface ConditionalFormatCellMatch extends ConditionalFormatCellMatchOptions {
+    type: 'cell-match';
+    area: IArea;
+    /** @internal */
+    internal?: {
+        vertex?: VertexPlaceholder;
+    };
+}
+export interface ConditionalFormatDuplicateValuesOptions {
+    style: CellStyle;
+    /** true to highlight unique cells, false to highlight duplicates. defaults to false. */
+    unique?: boolean;
+}
+export interface ConditionalFormatDuplicateValues extends ConditionalFormatDuplicateValuesOptions {
+    type: 'duplicate-values';
+    area: IArea;
+    /** @internal */
+    internal?: {
+        vertex?: VertexPlaceholder;
+    };
+}
+/**
+ * union, plus we're adding a state used to track application.
+ * that state is serialized if it's true.
+ * we also add an internal field that will be type-specific, and not serialized.
+ *
+ * ...everybody has a vertex now, we could standardize it
+ *
+ * update: adding a priority field, optional
+ *
+ */
+export type ConditionalFormat = {
+    internal?: unknown;
+    priority?: number;
+} & (ConditionalFormatDuplicateValues | ConditionalFormatExpression | ConditionalFormatCellMatch | ConditionalFormatGradient | ConditionalFormatDataBar);
+/**
+ * the list of formats, in reverse order of precedence. as a starting
+ * point we're using the naive approach, just applying everything in
+ * order. that may change.
+ */
+export type ConditionalFormatList = ConditionalFormat[];
+export {};

package/build/treb-data-model/src/conditional_format.js

@@ -0,0 +1,62 @@
+/*
+ * This file is part of TREB.
+ *
+ * TREB is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU General Public License as published by the Free Software
+ * Foundation, either version 3 of the License, or (at your option) any
+ * later version.
+ *
+ * TREB is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
+ * details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with TREB. If not, see <https://www.gnu.org/licenses/>.
+ *
+ * Copyright 2022-2026 trebco, llc.
+ * info@treb.app
+ *
+ */
+/**
+ *
+ * @internal
+ *
+ * @privateRemarks
+ *
+ * this is marked internal temporarily while I figure out why our API
+ * generator is not exporting the gradient stop type
+ */
+export const StandardGradientsList = {
+    'red-green': {
+        color_space: 'RGB',
+        stops: [
+            { value: 0, color: { theme: 5, tint: .5 } },
+            { value: 1, color: { theme: 9, tint: .5 } },
+        ],
+    },
+    'red-yellow-green': {
+        color_space: 'RGB',
+        stops: [
+            { value: 0, color: { theme: 5, tint: .5 } },
+            { value: 0.5, color: { theme: 7, tint: .5 } },
+            { value: 1, color: { theme: 9, tint: .5 } },
+        ],
+    },
+    'green-red': {
+        color_space: 'RGB',
+        stops: [
+            { value: 0, color: { theme: 9, tint: .5 } },
+            { value: 1, color: { theme: 5, tint: .5 } },
+        ],
+    },
+    'green-yellow-red': {
+        color_space: 'RGB',
+        stops: [
+            { value: 0, color: { theme: 9, tint: .5 } },
+            { value: 0.5, color: { theme: 7, tint: .5 } },
+            { value: 1, color: { theme: 5, tint: .5 } },
+        ],
+    },
+};
+//# sourceMappingURL=conditional_format.js.map

package/build/treb-data-model/src/conditional_format.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"conditional_format.js","sourceRoot":"","sources":["../../../treb-data-model/src/conditional_format.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAkDH;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG;IACnC,WAAW,EAAE;QACX,WAAW,EAAE,KAAK;QAClB,KAAK,EAAE;YACL,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,EAAE,KAAK,EAAE,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,EAAC;YAC1C,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,EAAE,KAAK,EAAE,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,EAAC;SACzB;KACpB;IACD,kBAAkB,EAAE;QAClB,WAAW,EAAE,KAAK;QAClB,KAAK,EAAE;YACL,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,EAAE,KAAK,EAAE,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,EAAC;YAC1C,EAAE,KAAK,EAAE,GAAG,EAAE,KAAK,EAAE,EAAE,KAAK,EAAE,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,EAAC;YAC5C,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,EAAE,KAAK,EAAE,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,EAAC;SACzB;KACpB;IACD,WAAW,EAAE;QACX,WAAW,EAAE,KAAK;QAClB,KAAK,EAAE;YACL,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,EAAE,KAAK,EAAE,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,EAAC;YAC1C,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,EAAE,KAAK,EAAE,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,EAAC;SACzB;KACpB;IACD,kBAAkB,EAAE;QAClB,WAAW,EAAE,KAAK;QAClB,KAAK,EAAE;YACL,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,EAAE,KAAK,EAAE,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,EAAC;YAC1C,EAAE,KAAK,EAAE,GAAG,EAAE,KAAK,EAAE,EAAE,KAAK,EAAE,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,EAAC;YAC5C,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,EAAE,KAAK,EAAE,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,EAAC;SACzB;KACpB;CACO,CAAC"}

package/build/treb-data-model/src/data-validation.d.ts

@@ -0,0 +1,28 @@
+import type { IArea, CellValue } from 'treb-base-types';
+/** @internal */
+export interface DataValidationRange {
+    type: 'range';
+    area: IArea;
+}
+/** @internal */
+export interface DataValidationList {
+    type: 'list';
+    list: CellValue[];
+}
+/** @internal */
+export interface DataValidationDate {
+    type: 'date';
+}
+/** @internal */
+export interface DataValidationNumber {
+    type: 'number';
+}
+/** @internal */
+export interface DataValidationBoolean {
+    type: 'boolean';
+}
+/** @internal */
+export type DataValidation = (DataValidationList | DataValidationRange | DataValidationNumber | DataValidationDate | DataValidationBoolean) & {
+    error?: boolean;
+    target: IArea[];
+};

package/build/treb-data-model/src/data-validation.js

@@ -0,0 +1,22 @@
+/*
+ * This file is part of TREB.
+ *
+ * TREB is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU General Public License as published by the Free Software
+ * Foundation, either version 3 of the License, or (at your option) any
+ * later version.
+ *
+ * TREB is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
+ * details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with TREB. If not, see <https://www.gnu.org/licenses/>.
+ *
+ * Copyright 2022-2026 trebco, llc.
+ * info@treb.app
+ *
+ */
+export {};
+//# sourceMappingURL=data-validation.js.map

package/build/treb-data-model/src/data-validation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-validation.js","sourceRoot":"","sources":["../../../treb-data-model/src/data-validation.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG"}

package/build/treb-data-model/src/data_model.d.ts

@@ -0,0 +1,173 @@
+import type { Sheet } from './sheet';
+import { SheetCollection } from './sheet_collection';
+import { type UnitAddress, type UnitStructuredReference, type UnitRange, Parser } from 'treb-parser';
+import type { IArea, ICellAddress, Table, CellStyle, CellValue } from 'treb-base-types';
+import { Area } from 'treb-base-types';
+import type { SerializedNamed } from './named';
+import { NamedRangeManager } from './named';
+import type { ConnectedElementType, MacroFunction } from './types';
+import type { LanguageModel } from './language-model';
+/**
+ *
+ */
+export declare class DataModel {
+    readonly parser: Parser;
+    /** moved from embedded spreadsheet */
+    language_model?: LanguageModel;
+    /** document metadata */
+    document_name?: string;
+    /**
+     * document metadata. this is opaque to everyone except the user, so
+     * we're intentionally leaving it as unknown except where users have
+     * direct access (embedded spreadsheet).
+     */
+    user_data?: unknown;
+    /**
+     *
+     */
+    readonly sheets: SheetCollection;
+    /** new composite collection (TODO: add macro functions too?) */
+    readonly named: NamedRangeManager;
+    /** macro functions are functions written in spreadsheet language */
+    readonly macro_functions: Map<string, MacroFunction>;
+    /** index for views */
+    view_count: number;
+    /**
+     * base style properties moved to model, so we can have a single
+     * and consistent reference.
+     */
+    theme_style_properties: CellStyle;
+    /**
+     * tables are global, because we need to reference them by name; and they
+     * need unique names, so we need to keep track of names. name matching is
+     * icase so we lc the names before inserting.
+     */
+    tables: Map<string, Table>;
+    /**
+     * we're wrapping up the get name method so we can check for a sheet
+     * name -- we have the list of sheet names. we could pass that to the
+     * name list manager but it's easier for us to intercept the call.
+     * I thought about wrapping up more API functions here, but that seems
+     * unecessary atm.
+     */
+    GetName(name: string, scope: number): import("./named").Named | undefined;
+    /**
+     * @param force_locale - always parse assuming a locale like en-us (comma
+     * argument separators). the current thinking is that this is required for
+     * XLSX import, although that might be incorrect.
+     */
+    UnserializeNames(names: SerializedNamed[], active_sheet?: Sheet, force_locale?: boolean): void;
+    /**
+     * serialize names. ranges are easy, but make sure there's a sheet name
+     * in each address (and remove the ID). expressions are a little more
+     * complicated.
+     */
+    SerializeNames(active_sheet?: Sheet): SerializedNamed[];
+    /**
+     * putting this here temporarily. it should probably move into a table
+     * manager class or something like that.
+     */
+    ResolveStructuredReference(ref: UnitStructuredReference, context: ICellAddress): UnitAddress | UnitRange | undefined;
+    /**
+     * return an address label for this address (single cell or range).
+     *
+     * this is doing something unexpected: for dynamic arrays, it seems
+     * to be filling out the full array. this could be an issue with how
+     * we're calling it in the specific case of external editors.
+     *
+     * there should be no case where this is actually intended, because
+     * the resulting label is garbage. nevertheless, I don't want to change
+     * any existing behavior so we will move it behind a flag and default to
+     * prior behavior. if necessary later we can change the default/remove the
+     * old behavior.
+     *
+     * @param address
+     * @param active_sheet
+     */
+    AddressToLabel(address: ICellAddress | IArea, correct_dynamic_arrays?: boolean): string;
+    /**
+     * returns false if the sheet cannot be resolved, which probably
+     * means the name changed (that's the case we are working on with
+     * this fix).
+     */
+    ResolveSheetID(expr: UnitAddress | UnitRange, context?: ICellAddress, active_sheet?: Sheet): boolean;
+    /** wrapper method ensures it always returns an Area (instance, not interface) */
+    ResolveArea(address: string | ICellAddress | IArea, active_sheet: Sheet, options?: {
+        r1c1?: boolean;
+    }): Area;
+    /**
+     * moved from embedded sheet. also modified to preserve ranges, so it
+     * might return a range (area). if you are expecting the old behavior
+     * you need to check (perhaps we could have a wrapper, or make it optional?)
+     *
+     * Q: why does this not go in grid? or model? (...)
+     * Q: why are we not preserving absoute/relative? (...)
+     *
+     */
+    ResolveAddress(address: string | ICellAddress | IArea, active_sheet: Sheet, options?: {
+        r1c1?: boolean;
+    }): ICellAddress | IArea;
+    AddConnectedElement(connected_element: ConnectedElementType): number;
+    RemoveConnectedElement(id: number): ConnectedElementType | undefined;
+    /**
+     * identifier for connected elements, used to manage. these need to be
+     * unique in the lifetime of a model instance, but no more than that.
+     */
+    protected connected_element_id: number;
+    /**
+     * these are intentionally NOT serialized. they're ephemeral, created
+     * at runtime and not persistent.
+     *
+     * @internal
+     */
+    connected_elements: Map<number, ConnectedElementType>;
+    /**
+     * maps common language (english) -> local language. this should
+     * be passed in (actually set via a function).
+     */
+    private language_map?;
+    /**
+     * maps local language -> common (english). this should be constructed
+     * when the forward function is passed in, so there's a 1-1 correspondence.
+     */
+    private reverse_language_map?;
+    /**
+     * set the language translation map. this is a set of function names
+     * (in english) -> the local equivalent. both should be in canonical form,
+     * as that will be used when we translate one way or the other.
+     */
+    SetLanguageMap(language_map?: Record<string, string>): void;
+    /**
+     * translate function from common (english) -> local language. this could
+     * be inlined (assuming it's only called in one place), but we are breaking
+     * it out so we can develop/test/manage it.
+     */
+    TranslateFunction(value: string, options?: {
+        r1c1?: boolean;
+    }): string;
+    /**
+     * translate from local language -> common (english).
+     * @see TranslateFunction
+     */
+    UntranslateFunction(value: string, options?: {
+        r1c1?: boolean;
+    }): string;
+    UntranslateData(value: CellValue | CellValue[] | CellValue[][], options?: {
+        r1c1?: boolean;
+    }): CellValue | CellValue[] | CellValue[][];
+    /**
+     * translation back and forth is the same operation, with a different
+     * (inverted) map. although it still might be worth inlining depending
+     * on cost.
+     *
+     * FIXME: it's about time we started using proper maps, we dropped
+     * support for IE11 some time ago.
+     */
+    private TranslateInternal;
+    /**
+     * this is not public _yet_
+     *
+     * @internal
+     */
+    SetLanguage(model?: LanguageModel): void;
+}