carrick 0.3.110 → 0.3.112

package/sidecar/dist/src/type-inferrer.d.ts

@@ -38,6 +38,21 @@ import type { InferRequestItem, InferResult, ExtractionConfig } from './types.js
  * test (`machinery-indicator-mirror.test.ts`) asserts the two sets stay equal.
  */
 export declare const MACHINERY_MEMBER_INDICATORS: Set<string>;
+/**
+ * `text` is `string`, alone or beside `null` and `undefined` in either order:
+ * the only payload a raw-text read publishes (carrick#1842).
+ */
+/**
+ * Source text with every plain string literal written in double quotes:
+ * `'/a'`, `"/a"` and an interpolation-free `` `/a` `` are one value, so text
+ * that differs only in its quotes compares equal (carrick#2056).
+ *
+ * The text is read left to right, pairing quotes the way the scanner does,
+ * so a template's closing backtick never pairs with the next template's
+ * opening one. A literal holding a quote, a backslash or an interpolation is
+ * copied as it is, and so is an unterminated one with everything after it.
+ */
+export declare function canonicalStringQuotes(text: string): string;
 /**
  * Options for TypeInferrer construction
  */
@@ -273,6 +288,24 @@ export declare class TypeInferrer {
      * returns the repo's own type (`toInstance(View, plain)`) is the payload.
      */
     private callResultIsPayload;
+    /**
+     * True when a located call evaluates to plain data, so it is the payload
+     * whatever its arguments and wherever its type is declared (carrick#2055).
+     *
+     * `rows.map(toDto)`, `rows.filter(cb)` and `listItems(ownerId)` produce the
+     * list a route sends. Read as a send, the first produced the mapper's
+     * function type, the second a callback's return, and the third `string`.
+     * What a send or a registration hands back is never plain data: a reply
+     * builder or a router carries methods, a bare send returns `void`, and a
+     * serialiser returns a primitive. So the result alone tells them apart.
+     *
+     * Plain data, once promise levels are taken off: an object with at least
+     * one member, no call or construct signature, and no member that is itself
+     * callable; an array of one; or a union whose members other than `null` and
+     * `undefined` all are. Tuples and empty objects are left to the callers'
+     * own reading.
+     */
+    private callResultIsPlainData;
     /**
      * The wire representation a request's printed type takes. A route response
      * is serialised as JSON by every sender this layer reads a payload out of,
@@ -297,7 +330,8 @@ export declare class TypeInferrer {
      *
      * Returns `undefined` when this does not apply, which leaves the caller's
      * own reading of the located expression untouched:
-     *  - the row's line is not a route registration;
+     *  - the row's line is neither a route registration nor a line inside the
+     *    handler the located send sits in;
      *  - the located expression is neither a send nor the argument of one;
      *  - that send is not one the handler returns;
      *  - it is a success send and the only one that survives, so the join would
@@ -366,6 +400,11 @@ export declare class TypeInferrer {
      * belongs to a read.
      */
     private typeNodeStatedAtRead;
+    /**
+     * A wrapper between a body read and the binding it initialises that leaves
+     * the read's value as it is: `await`, parentheses, `!`, a cast, `satisfies`.
+     */
+    private wrapsReadTransparently;
     /**
      * A stated type with `any` or `unknown` written anywhere in it (`unknown`,
      * `Record<string, unknown>`, `{ items: any[] }`) leaves a position open: it
@@ -1067,6 +1106,16 @@ export declare class TypeInferrer {
      * No method or framework name is consulted anywhere.
      */
     private responseSiteStatus;
+    /**
+     * The status an earlier call of a send's own chain states: the receiver
+     * calls `call` is invoked on (`a.status(401).json(body)` has `a.status(401)`),
+     * innermost last. Each receiver call's first argument is read by the rule
+     * an argument past a body is, so a numeric literal or a literal-typed value
+     * counts and a plain `number` is `variable`. `undefined` when no receiver
+     * call states a status. No method name is consulted: a receiver call that
+     * is handed no status-shaped value says nothing.
+     */
+    private chainStatus;
     /**
      * The HTTP status codes an argument states, `'variable'` when it is a
      * status-shaped value the source does not fix, or `undefined` when it says
@@ -1104,6 +1153,19 @@ export declare class TypeInferrer {
      * followed to a small depth; anything else is returned as itself.
      */
     private expandResponseBranches;
+    /**
+     * The symbol an anchor is named from: the type's own symbol, unless that
+     * symbol's name is synthetic (`__type`, `__object`, ...), in which case the
+     * alias symbol (carrick#2148).
+     *
+     * `type Widget = { id: string }` and an instantiated `Page<Order>` carry
+     * the anonymous `__type` as their own symbol and the alias as their alias
+     * symbol. Reading the own symbol first and stopping because it is truthy
+     * left every object-literal alias without an anchor, while the same shape
+     * declared as an interface had one. The own symbol still wins whenever it
+     * has a real name, so every type anchored before keeps its anchor.
+     */
+    private anchorSymbolOf;
     /**
      * The deterministic source symbol of a resolved type (`Payment` for a payload
      * typed `Payment`), or `undefined` when there is no single user-defined
@@ -1125,7 +1187,8 @@ export declare class TypeInferrer {
      * declarations IN its `source_file`, so the request must point at the file
      * that actually declares the tsc-witnessed payload type.
      *
-     * The declarations read are those of the type's own symbol, so a name
+     * The declarations read are those of the symbol the anchor is named from
+     * (`anchorSymbolOf`: the type's own symbol, or its alias's), so a name
      * imported through a barrel reports the file that declares it, and a name
      * two files declare reports the one this type resolves to. A declaration in
      * an installed package or a TypeScript lib is reported as it is found, as
@@ -1431,6 +1494,18 @@ export declare class TypeInferrer {
      * The first such call in source order: a body is read once.
      */
     private platformBodyReadIn;
+    /**
+     * The platform body read whose result `located` is a MEMBER of, or
+     * `undefined` (carrick#2057).
+     *
+     * A member is a property or element access off a binding, or a name
+     * destructured out of one. The binding must be initialised by the body read
+     * `platformBodyReadIn` finds in the function that declares it, with only
+     * transparent wrappers between the two (`await`, parentheses, `!`, a cast,
+     * `satisfies`). The binding itself is not a member, and neither is a member
+     * of anything else (a query object, a parameter, an outbound response).
+     */
+    private parsedBodyReadHolding;
     /**
      * The request contract the source states AT a body read, or null when it
      * states none there (carrick#807).
@@ -1544,6 +1619,27 @@ export declare class TypeInferrer {
      * whose type does not resolve the member, or an opaque config, abstains.
      */
     private requestBodyInCall;
+    /** A string, a string literal, a template literal, or a union of strings. */
+    private isStringLikeType;
+    /**
+     * carrick#1841, request half: a request call that states its URL on its one
+     * object argument (`client.post({ url: '/items', ...options })`, the way a
+     * generated client issues every operation). The method's own parameter
+     * types the body `unknown`, so the object is the only statement of it: its
+     * `body` member, the member `RequestInit` defines, written on the object or
+     * carried in by a spread whose type says what it is.
+     *
+     * - A `body` written after the object's last spread is the body.
+     * - Otherwise the object's own type has the answer. No `body` member, or
+     *   one typed `undefined` or `never`, means the call sends no body.
+     * - A member typed `any`, `unknown` or a type parameter, or one only the
+     *   compiler's default library declares (a spread `RequestInit` carries the
+     *   serialised `BodyInit`, not a payload), states no payload: abstain. So
+     *   does an object that carries another body-named member and no `body`.
+     *
+     * An object with no string-typed `url` member is not a request object.
+     */
+    private requestObjectBody;
     /**
      * The body a config-slot argument supplies through `member`: an object
      * literal's own member, or a variable's member read off its type.
@@ -1838,6 +1934,20 @@ export declare class TypeInferrer {
      * then substring match (preferring containing matches).
      */
     private matchByText;
+    /**
+     * What a locator's text names, read off its own parse (carrick#2056):
+     *
+     *  - `texts`: the normalized text of the expression it names and of each
+     *    wrapper it carries around it (`return`, a `const x =` binding, a label,
+     *    `await`, parentheses, a cast, `satisfies`, `!`). A node strictly inside
+     *    that expression is not among them;
+     *  - `rootKind` and `rootStart`: the innermost of those, its kind, and where
+     *    its text starts in the locator.
+     *
+     * `null` when the text does not parse as one expression or one statement:
+     * there is no structure to read, and the caller keeps its text rule.
+     */
+    private locatorNames;
     /**
      * Pick the best match from a set of candidate nodes:
      * smallest range, then closest to target line.