@sheetxl/primitives 0.7.28-beta.4 → 0.8.0-beta.2

package/types/src/ValueKind.d.ts

@@ -0,0 +1,43 @@
+/**
+ * The KIND of one value — the total discriminator over {@link IFunctionArguments.RawArg}, and the
+ * vocabulary a RETURN declaration speaks ({@link IFunction.IReturnType.getKind}).
+ *
+ * @remarks
+ * A value's kind and its extent are different axes: `{10}`, `A1` and a bare `10` all reach a
+ * range-typed parameter as a 1x1 container, yet Excel separates them:
+ * `VLOOKUP(10,10,1,TRUE)` is `#N/A` while `VLOOKUP(10,{10},1,TRUE)` is 10, and `TYPE` answers
+ * 1 vs 64. The kind is what the CALLER supplied; the extent is merely its size.
+ *
+ * The scalar kinds ARE {@link ScalarType} values — one vocabulary, so
+ * `getKindAt(i) === ScalarType.Boolean` reads naturally — extended with the four kinds only an
+ * argument can be: a reference, a non-reference array, a callable, and no argument at all. As an
+ * argument kind, {@link ScalarType.Null} means a BLANK value.
+ *
+ * The names and values are ours. The numeric codes Excel's `TYPE` function answers are a
+ * PROJECTION of this kind (see `TYPE`'s implementation), not the kind itself.
+ *
+ * @see {@link IFunctionArguments.getKindAt}
+ */
+export declare const ValueKind: {
+    /** A reference — `A1`, `A1:B3`, or a reference-returning call (`INDEX`, `OFFSET`, `TAKE`). */
+    readonly Reference: "reference";
+    /** An ARRAY that is not a reference — `{1,2}`, or a computed one (`SEQUENCE`, `TRANSPOSE(…)`). */
+    readonly Array: "array";
+    /** A callable — `LAMBDA(…)`, an eta-reduced function name, or a lambda-valued binding. */
+    readonly Lambda: "lambda";
+    /**
+     * OMITTED — nothing at this position: the empty comma of `CUMIPMT(,120,…)`, or a position
+     * past what the caller wrote. A blank CELL is a `Reference` (blankness is the cell's value).
+     * ABSENT-vs-omitted — whether the position exists in the call at all — is not a kind; it is
+     * `index >= getLength()`.
+     */
+    readonly Omitted: "omitted";
+    readonly Number: "number";
+    readonly String: "string";
+    readonly Boolean: "boolean";
+    readonly Error: "error";
+    readonly RichData: "richData";
+    readonly Null: "null";
+};
+export type ValueKind = typeof ValueKind[keyof typeof ValueKind];
+//# sourceMappingURL=ValueKind.d.ts.map

package/types/src/Volatile.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Declares that a function's RESULT can change with nothing dirty, so a cell naming it
+ * recalculates on every pass.
+ *
+ * ```ts
+ * export function NOW(): Volatile<number> { ... }
+ * ```
+ *
+ * @see {@link IFunction.ReturnTypeJSON.volatile}
+ */
+export type Volatile<T> = T;
+//# sourceMappingURL=Volatile.d.ts.map

package/types/src/WildCard.d.ts

@@ -10,17 +10,21 @@ export declare const WildCard: {
     /**
      * Compiles Excel wildcard text into a regex.
      *
-     * @param anchor Whether the pattern must match the WHOLE string. Excel matches a whole cell, so
-     * every lookup and criteria caller anchors; `SEARCH`, which looks for a substring, does not.
+     * @param anchor Where the pattern has to line up: `true` for the WHOLE string, `'start'` for a
+     * PREFIX, `false` for anywhere in it. Excel matches a whole cell, so every lookup and criteria
+     * caller anchors; `SEARCH`, which looks for a substring, does not; and a `D` function's criteria
+     * table is the prefix form — `DSUM` with the criterion `appl` takes the row whose value is
+     * `Apple`, where `COUNTIF` with the same criterion takes none.
      *
      * @remarks
-     * `~` escapes the next `*`, `?` or `~`; standing alone it is a literal tilde (`COUNTIF(range,
-     * "a~b")` finds the text `a~b`). One left-to-right pass, because chained replaces cannot express
-     * this: the previous implementation guarded its `*`/`?` rewrites with `([^~]??)`, a lazy OPTIONAL
-     * group that matches empty and so guards nothing, and then unescaped `~([?*])` — which could
-     * never fire, the `*` and `?` having already become `.*` and `.`. Every escape was silently
-     * ignored, so `"~*"` compiled to `~.*`: a literal tilde followed by anything.
+     * `~` escapes the next `*`, `?` or `~`; before anything else it is dropped, not kept —
+     * `SEARCH("~b","abc")` is 2 and `MATCH("a~b",…)` finds the text `ab`. A caller that reaches this
+     * compiler only when the pattern holds a `*` or `?` — which is what COUNTIF and its family do —
+     * therefore still compares `"a~b"` literally, because that criteria never becomes a pattern.
+     *
+     * One left-to-right pass; chained replaces cannot express the escape, since by the time a pass
+     * could unescape `~*` the `*` has already become `.*`.
      */
-    toRegex: (lookupText: string, flags?: any, anchor?: boolean) => RegExp;
+    toRegex: (lookupText: string, flags?: any, anchor?: boolean | "start") => RegExp;
 };
 //# sourceMappingURL=WildCard.d.ts.map

package/types/src/index.d.ts

@@ -1,16 +1,23 @@
 export * from './Scalar';
 export * from './ScalarType';
+export * from './ValueKind';
 export * from './WildCard';
 export * from './Lambda';
 export * from './ErrorPolicy';
 export * from './Repeating';
 export * from './Flatten';
+export * from './NoLift';
+export * from './NoFilter';
+export * from './ReportType';
 export * from './Omittable';
+export * from './Lazy';
+export * from './Volatile';
 export * from './IRange';
 export * from './IReferenceRange';
 export * from './IRichData';
 export * from './IFunction';
 export * from './IFormulaContext';
+export * from './IFunctionArguments';
 export * from './LocaleProfile';
 export * from './IRuntime';
 export * from './IRangeStats';