@sheetxl/sdk 0.7.26 → 0.7.28-beta.1

package/types/src/fill/IStroke.d.ts

@@ -0,0 +1,265 @@
+import { Properties as CSSProperties } from 'csstype';
+import { Bounds } from '@sheetxl/utils';
+import { IColor } from '../color';
+import { IFill } from '../fill';
+/**
+ * *** **PLACEHOLDER** - Not yet implemented.
+ *
+ * Defines how a stroke is drawn around a shape.
+ */
+export interface IStroke {
+    /**
+     * Fill properties for the stroke.
+     */
+    getFill(): IFill.ISolid | IFill.IGradient | IFill.IPattern | IFill.INone;
+    /**
+     * Returns the stroke as a set of css string that are suitable for css.
+     *
+     * @remarks
+     * Not all fill styles will offer an exact css equivalent.
+     * Additionally due to the nature of css having different properties for the same logic value
+     * (for example color, backgroundColor)
+     */
+    toCSS(mode?: IColor.CSSMode, bounds?: Bounds): CSSProperties;
+    /**
+     * Returns the stroke as a json object.
+     */
+    toJSON(): IStroke.JSON;
+}
+/**
+ * {@inheritDoc IStroke}
+ * @see
+ * ### **Interface**
+ *
+ * {@link IStroke}
+ */
+export declare namespace IStroke {
+    interface Properties {
+        /**
+         * Fill properties for the stroke.
+         */
+        fill: IFill.Properties;
+        /**
+         * The width of the stroke.
+         *
+         * @remarks
+         * Indicates the thickness of the stroke in pixels.
+         */
+        width: number;
+        /**
+         * Defines the shape to be used at the corners of paths when they are stroked.
+         */
+        lineJoin: IStroke.LineJoin;
+        /**
+         * Defining the shape to be used at the end of open subpaths when they are stroked.
+         *
+         * @see {@link https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/stroke-linecap}
+         */
+        lineCap: IStroke.LineCap;
+        /**
+         * Defining a limit on the ratio of the miter length to the stroke-width
+         * used to draw a miter join. When the limit is exceeded, the join is converted
+         * from a miter to a bevel.
+         *
+         * @defaultValue `10`.
+         *
+         * @see {@link https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/stroke-miterlimit}
+         */
+        miterLimit: number;
+        /**
+         * Defines the arrowhead or shape that will be drawn at the first vertex of the given shape.
+         *
+         * @defaultValue `null`.
+         *
+         * @see {@link https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/marker-start}
+         *
+         */
+        markerStart: IStroke.IMarker;
+        /**
+         * Defines the arrowhead or shape that will be drawn at all interior vertices of the given shape.
+         *
+         * @defaultValue `null`.
+         *
+         * @see {@link https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/marker-mid}
+         *
+         */
+        markerMid: IStroke.IMarker;
+        /**
+         * Defines the arrowhead or shape that will be drawn at final vertex for the given shape.
+         *
+         * @defaultValue `null`.
+         *
+         * @see {@link https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/marker-end}
+         *
+         */
+        markerEnd: IStroke.IMarker;
+        /**
+         * Custom or preset for the stroke.
+         */
+        dash: number[] | string;
+        /**
+         * Indicates the type of compound stroke.
+         *
+         * @defaultValue IStroke.Compound.Single
+         *
+         * @remarks
+         * Only single is supported for rendering.
+         *
+         */
+        compound: IStroke.Compound;
+        /**
+         * Indicates the alignment of the stroke.
+         *
+         * * @defaultValue IStroke.Align.Center
+         *
+         * @remarks
+         * Only center is supported for rendering.
+         */
+        align: IStroke.Align;
+    }
+    /**
+     * A Marker is a custom placeholder for shapes along a stroke.
+     *
+     * @remarks
+     * The Marker contains the positioning and shape of the marker.
+     *
+     * @see {@link https://developer.mozilla.org/en-US/docs/Web/SVG/Element/marker}
+     */
+    interface IMarker {
+        width: number;
+        height: number;
+        axis: number;
+        shape: IStroke.PresetMarkerShape;
+    }
+    /**
+     * Support stroke with multiple strokes.
+     * ** PLACEHOLDER **
+     */
+    const Compound: {
+        /**
+         * Single line: one normal width
+         */
+        readonly Single: "sng";
+        /**
+         * Double line: two parallel lines of equal width
+         */
+        readonly Double: "dbl";
+        /**
+         * Double lines: one thick, one thin
+         */
+        readonly ThickThin: "thickThin";
+        /**
+         * Double lines: one thin, one thick
+         */
+        readonly ThinThick: "thinThick";
+        /**
+         * Three lines: thin, thick, thin
+         */
+        readonly Triple: "tri";
+    };
+    type Compound = typeof Compound[keyof typeof Compound];
+    /**
+     * Specific alignment for the stroke.
+     */
+    const Align: {
+        /**
+         * Centered on the path.
+         */
+        readonly Center: "ctr";
+        /**
+         * Inset from the path.
+         */
+        readonly Inset: "in";
+        /**
+         * outset line
+         *
+         * @remarks
+         * Not support by ooxml
+         */
+        readonly Outset: "outset";
+    };
+    type Align = typeof Align[keyof typeof Align];
+    /**
+     * Indicates the shape of an end of a stroke.
+     * @see {@link https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/stroke-linecap}
+     */
+    const LineCap: {
+        /**
+         * Indicates that the stroke for each subpath does not extend beyond its two endpoints.
+         * On a zero length subpath, the path will not be rendered at all
+         */
+        readonly Butt: "butt";
+        /**
+         * Indicates that at the end of each subpath the stroke will be extended by a half
+         * circle with a diameter equal to the stroke width. On a zero length subpath, the stroke
+         * consists of a full circle centered at the subpath's point.
+         */
+        readonly Round: "round";
+        /**
+         * Indicates that at the end of each subpath the stroke will be extended by a rectangle
+         * with a width equal to half the width of the stroke and a height equal to the width of
+         * the stroke. On a zero length subpath, the stroke consists of a square with its width
+         * equal to the stroke width, centered at the subpath's point.
+         */
+        readonly Square: "square";
+    };
+    type LineCap = typeof LineCap[keyof typeof LineCap];
+    /**
+     * Indicates the shape to be used at the corners of paths when they are stroked.
+     *
+     * @see {@link https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/stroke-linejoin}
+     */
+    const LineJoin: {
+        /**
+         * Indicates that a bevelled corner is to be used to join path segments.
+         *
+         * @see {@link https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/stroke-linejoin#bevel}
+         */
+        readonly Bevel: "bevel";
+        /**
+         * Indicates that a sharp corner is to be used to join path segments. The corner is formed by extending
+         * the outer edges of the stroke at the tangents of the path segments until they intersect.
+         *
+         * @see {@link https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/stroke-linejoin#miter}
+         *
+         * @remarks
+         * If the stroke-miterlimit is exceeded, the line join falls back to bevel.
+         */
+        readonly Miter: "miter";
+        /**
+         * Indicates that a round corner is to be used to join path segments.
+         *
+         * @see {@link https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/stroke-linejoin#round}
+         */
+        readonly Round: "round";
+    };
+    type LineJoin = typeof LineJoin[keyof typeof LineJoin];
+    const PresetMarkerShape: {
+        readonly Single: "none";
+        readonly Double: "double";
+        readonly ThickThin: "thickThin";
+        readonly ThinThick: "thickThin";
+    };
+    type PresetMarkerShape = typeof PresetMarkerShape[keyof typeof PresetMarkerShape];
+    const StrokeStyle: {
+        readonly None: "none";
+        readonly Dashed: "dashed";
+        readonly Dotted: "dotted";
+        readonly LargeDash: "lgDash";
+        readonly LargeDashDot: "lgDashDot";
+        readonly LargeDashDotDot: "lgDashDotDot";
+        readonly Solid: "solid";
+        readonly SysDash: "sysDash";
+        readonly SysDashDot: "sysDashDot";
+        readonly SysDashDotDot: "sysDashDotDot";
+        readonly SysDot: "sysDot";
+    };
+    type StrokeStyle = typeof StrokeStyle[keyof typeof StrokeStyle];
+    /**
+     * A JSON representation useful for persistence.
+     */
+    interface JSON extends Properties {
+        fill: IFill.JSON;
+    }
+}
+//# sourceMappingURL=IStroke.d.ts.map

package/types/src/fill/_BuiltInPatterns.d.ts

@@ -0,0 +1,27 @@
+import { Properties as CSSProperties } from 'csstype';
+import { IFill } from './IFill';
+declare class BuiltInPatternLookup {
+    private _svgImage;
+    /**
+     * Single-element (baked) form: the marks color is INSIDE an SVG data-URI, so it cannot be
+     * adaptive (`light-dark()` in a data-URI image never sees the host `color-scheme`). Prefer
+     * {@link toCSSMask} for live rendering.
+     */
+    toCSS(pattern: IFill.BuiltInSheetPattern, foreground: string, background: string): CSSProperties;
+    /**
+     * Two-layer (adaptive-capable) form: a `base` (solid background color) plus `marks` — the
+     * foreground color masked by the pattern tile (`mask-image` data-URI, color-independent). Both
+     * colors are ordinary live CSS values, so `light-dark()` / `var()` work — a mode flip re-resolves
+     * with no re-render. Render `marks` as a child box filling the `base` element (a mask clips the
+     * element it's set on, so the two colors need two elements).
+     *
+     * Returns `null` for `None`/`Solid` — no marks layer; use {@link toCSS} (single element) there.
+     */
+    toCSSMask(pattern: IFill.BuiltInSheetPattern, foreground: string, background: string): {
+        base: CSSProperties;
+        marks: CSSProperties;
+    } | null;
+}
+export declare const _BuiltInPatterns: BuiltInPatternLookup;
+export {};
+//# sourceMappingURL=_BuiltInPatterns.d.ts.map

package/types/src/fill/index.d.ts

@@ -0,0 +1,4 @@
+export * from './IFill';
+export * from './IStroke';
+export * from './IEffect';
+//# sourceMappingURL=index.d.ts.map

package/types/src/filter/IFilter.d.ts

@@ -0,0 +1,83 @@
+import { IRange } from '@sheetxl/primitives';
+import { ITransaction } from '../transaction';
+import { ICondition } from '../condition';
+import { ICellRange } from '../cellRange';
+/**
+ * Filters are used to hide spans (rows or columns). that do not match a set of conditions.
+ */
+export interface IFilter extends ICondition.Stateful, IFilter.IFilterable {
+    /**
+     * Returns the range this filter applies to.
+     *
+     * @remarks
+     * A filter is exactly one column of its table, which is why the singular is declared here rather
+     * than on {@link ICondition.Stateful}.
+     */
+    getRange(): ICellRange;
+    /**
+     * Set the condition.
+     */
+    setCondition(condition: ICondition.Input, append?: boolean, options?: ITransaction.OperationOptions): void;
+    /**
+     * The offset index from the range
+     *
+     * @remarks
+     * This is relative to the table.
+     */
+    getIndex(): number;
+}
+/**
+ * {@inheritDoc IFilter}
+ * @see
+ * ### **Interface**
+ *
+ * {@link IFilter}
+ */
+export declare namespace IFilter {
+    interface JSON {
+        conditions?: ICondition.JSON[];
+        axis?: IRange.Axis;
+    }
+    /**
+     * Interface indicating the ability to filter data.
+     */
+    interface IFilterable {
+        /**
+         * Filter the range using a condition.
+         *
+         * @remarks
+         *
+         * Examples:
+         *
+         * keep only values greater than or equal to 30:
+         *
+         * ``` ts - JSON param
+         * sheet.getRange('E:E').filter({
+         *   operator: ICondition.BuiltInOperatorNames.GreaterThanOrEqual,
+         *   param: 30
+         * });
+         * ```
+         *
+         * Example 2 – function param
+         *
+         * ``` ts
+         * sheet.getRange('E:E').filter(value => value >= 30);
+         * // or with context: (e.g., to ignore header row)
+         * sheet.getRange('E:E').filter((value, ctx) => {
+         *   const { rowIndex } = ctx.getCoords();
+         *   return rowIndex > 1 && value >= 30;
+         * });
+         * ```
+         *
+         * Example 3 – string
+         * The expression is parsed using the same rules as user input
+         * (e.g., `"30"` is a number, `"=A1*2"` is a formula, `"40%"` is 0.4).
+         *
+         * ``` ts
+         * sheet.getRange('E:E').filter('>= 30');
+         * ```
+         */
+        filter(condition?: ICondition.Input, options?: ITransaction.OperationOptions): this;
+    }
+}
+//# sourceMappingURL=IFilter.d.ts.map

package/types/src/filter/index.d.ts

@@ -0,0 +1,2 @@
+export * from './IFilter';
+//# sourceMappingURL=index.d.ts.map

package/types/src/font/CanvasFontMeasurer.d.ts

@@ -0,0 +1,25 @@
+import { IFont } from './IFont';
+/**
+ * A canvas based getTextMetrics.
+ *
+ * Canvas has limited support for font metrics we can do css sniffing to find lineGap but all
+ * rendering values (underline offset/width, stroke offset/width, subSetting, italic angle, etc)
+ * are not available in browsers.
+ *
+ * To this end we approximate.
+ * * lineGap.
+ * * underlineOffset
+ * * underlineWidth
+ * * stroke offset
+ *
+ */
+export declare function CanvasFontMeasurer(text: string, size: number, family: string, options?: IFont.MetricOptions | null): IFont.ExtendedMetrics;
+export declare function getInstance(): IFont.Measurer;
+/**
+ * Returns scaling to use for the current device.
+ *
+ * @remarks
+ * **TODO** This is hardcoded to Non-HD DPI. Revisit.
+ */
+export declare function getDeviceScale(): number;
+//# sourceMappingURL=CanvasFontMeasurer.d.ts.map

package/types/src/font/ExtendedTextMetrics.d.ts

@@ -0,0 +1 @@
+//# sourceMappingURL=ExtendedTextMetrics.d.ts.map

package/types/src/font/Font.d.ts

@@ -0,0 +1,19 @@
+import { IFont } from './IFont';
+/**
+ * read only font face
+ * @hidden
+ */
+export declare class SimpleFontFace implements IFont.IFontFace {
+    _private: any;
+    constructor(input: any);
+    toJSON(): any;
+    /** {@inheritDoc IFont.getFamily} */
+    getFamily(): string;
+    /** {@inheritDoc IFont.getPitch} */
+    getPitch(): string;
+    /** {@inheritDoc IFont.getPanose} */
+    getPanose(): string | null;
+    toString(): any;
+    get isIFont(): true;
+}
+//# sourceMappingURL=Font.d.ts.map

package/types/src/font/FontKitFontMeasurer.d.ts

@@ -0,0 +1,11 @@
+import { IFont } from './IFont';
+export declare function setFontFolder(path: string): void;
+/**
+ * TODO - use fs selection to determine:
+ * 1. panose
+ * 2. if bold, italic
+ */
+export declare function FontKitFontMeasurer(text: string, size: number, family: string, options?: IFont.MetricOptions | null): IFont.ExtendedMetrics;
+export declare function getInstance(): IFont.Measurer;
+export declare function getDeviceScale(): number;
+//# sourceMappingURL=FontKitFontMeasurer.d.ts.map

package/types/src/font/FontUtils.d.ts

@@ -0,0 +1,9 @@
+/**
+ * A list of font sizes for showing in drop downs.
+ */
+export declare const DefaultFontSizes: readonly number[];
+/**
+ * Searches an array of numbers for the next value.
+ */
+export declare function findNextFontSize(size: number, increase?: boolean, steps?: readonly number[]): number;
+//# sourceMappingURL=FontUtils.d.ts.map