basalt-core 0.0.0-rc5

package/dist/src/quitRequest.d.ts

@@ -0,0 +1,55 @@
+/**
+ * `useQuitRequest()` -- being asked before the application terminates.
+ *
+ * The same mechanism as `useCloseRequest()`, one level up, and it exists
+ * because the window half is not enough: an app can guard every window it
+ * owns and still lose the person's work to Cmd-Q. macOS routes quitting
+ * through `applicationShouldTerminate:` and asks no window whether it minds;
+ * a session ending on Linux or Windows does the same.
+ *
+ * ## Why a registration rather than a returned `false`
+ *
+ * Identical to the window case, and see src/closeRequest.ts for the long
+ * version: the handler is JavaScript on another thread and the system wants a
+ * synchronous yes or no, so the decision has to exist before the attempt.
+ * Registering is what makes it exist -- the host then refuses the quit and
+ * reports it, and the app quits itself when it is ready.
+ *
+ * ## One handler, not one per window
+ *
+ * Quitting is one event no matter how many windows are open, so this is not
+ * addressed to a window and the handler takes no id. An app that registers
+ * from two components gets asked twice and can quit twice, which is
+ * harmless -- the second `quit()` arrives at a process that is already
+ * going -- but is not the intended shape. Register it once, near the top.
+ *
+ * ## What each desktop means by "quit"
+ *
+ * On macOS this is Cmd-Q, the Quit menu item, and logging out. On Windows and
+ * Linux there is no application-level quit gesture to intercept -- an app ends
+ * when its last window closes, which is a window close and `useCloseRequest`'s
+ * business -- so what this catches there is the session ending: logout,
+ * shutdown, reboot.
+ *
+ * @format
+ */
+/**
+ * What the handler is given: call it to let the quit through. It stops
+ * intercepting first, so the quit it then asks for is not refused by the
+ * registration that produced the question.
+ */
+export type AllowQuit = () => void;
+export type QuitRequestHandler = (quit: AllowQuit) => void;
+/** Whether this platform can be asked at all. */
+export declare const isSupported: boolean;
+/**
+ * Ask to be asked before the application quits.
+ *
+ * Pass null to stop asking. The handler is read through a ref, so an app that
+ * passes a new closure every render does not re-register -- what re-runs the
+ * effect is whether there is a handler at all, plus `deps`.
+ */
+export declare function useQuitRequest(handler: QuitRequestHandler | null | undefined, deps?: ReadonlyArray<unknown>): void;
+/** Ends the application, asking nobody. */
+export declare function quit(): void;
+//# sourceMappingURL=quitRequest.d.ts.map

package/dist/src/quitRequest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"quitRequest.d.ts","sourceRoot":"","sources":["../../src/quitRequest.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AAMH;;;;GAIG;AACH,MAAM,MAAM,SAAS,GAAG,MAAM,IAAI,CAAC;AAEnC,MAAM,MAAM,kBAAkB,GAAG,CAAC,IAAI,EAAE,SAAS,KAAK,IAAI,CAAC;AAY3D,iDAAiD;AACjD,eAAO,MAAM,WAAW,SAAuC,CAAC;AAEhE;;;;;;GAMG;AACH,wBAAgB,cAAc,CAC5B,OAAO,EAAE,kBAAkB,GAAG,IAAI,GAAG,SAAS,EAC9C,IAAI,GAAE,aAAa,CAAC,OAAO,CAAM,GAChC,IAAI,CAgCN;AAED,2CAA2C;AAC3C,wBAAgB,IAAI,IAAI,IAAI,CAE3B"}

package/dist/src/quitRequest.js

@@ -0,0 +1,121 @@
+"use strict";
+/**
+ * `useQuitRequest()` -- being asked before the application terminates.
+ *
+ * The same mechanism as `useCloseRequest()`, one level up, and it exists
+ * because the window half is not enough: an app can guard every window it
+ * owns and still lose the person's work to Cmd-Q. macOS routes quitting
+ * through `applicationShouldTerminate:` and asks no window whether it minds;
+ * a session ending on Linux or Windows does the same.
+ *
+ * ## Why a registration rather than a returned `false`
+ *
+ * Identical to the window case, and see src/closeRequest.ts for the long
+ * version: the handler is JavaScript on another thread and the system wants a
+ * synchronous yes or no, so the decision has to exist before the attempt.
+ * Registering is what makes it exist -- the host then refuses the quit and
+ * reports it, and the app quits itself when it is ready.
+ *
+ * ## One handler, not one per window
+ *
+ * Quitting is one event no matter how many windows are open, so this is not
+ * addressed to a window and the handler takes no id. An app that registers
+ * from two components gets asked twice and can quit twice, which is
+ * harmless -- the second `quit()` arrives at a process that is already
+ * going -- but is not the intended shape. Register it once, near the top.
+ *
+ * ## What each desktop means by "quit"
+ *
+ * On macOS this is Cmd-Q, the Quit menu item, and logging out. On Windows and
+ * Linux there is no application-level quit gesture to intercept -- an app ends
+ * when its last window closes, which is a window close and `useCloseRequest`'s
+ * business -- so what this catches there is the session ending: logout,
+ * shutdown, reboot.
+ *
+ * @format
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSupported = void 0;
+exports.useQuitRequest = useQuitRequest;
+exports.quit = quit;
+const React = __importStar(require("react"));
+const react_native_1 = require("react-native");
+const NativeWindows = react_native_1.TurboModuleRegistry.get('BasaltWindows');
+// Must match kQuitRequestedEvent in native/core/WindowsModule.h.
+const QUIT_REQUESTED_EVENT = 'basaltQuitRequested';
+/** Whether this platform can be asked at all. */
+exports.isSupported = NativeWindows?.interceptQuit != null;
+/**
+ * Ask to be asked before the application quits.
+ *
+ * Pass null to stop asking. The handler is read through a ref, so an app that
+ * passes a new closure every render does not re-register -- what re-runs the
+ * effect is whether there is a handler at all, plus `deps`.
+ */
+function useQuitRequest(handler, deps = []) {
+    const handlerRef = React.useRef(handler);
+    handlerRef.current = handler;
+    const wanted = handler != null;
+    React.useEffect(() => {
+        if (!exports.isSupported || !wanted) {
+            return;
+        }
+        // `isSupported` above is what proves these are here; it is computed at
+        // module scope from the same optional call, which the compiler cannot
+        // follow.
+        NativeWindows.interceptQuit(true);
+        const subscription = react_native_1.DeviceEventEmitter.addListener(QUIT_REQUESTED_EVENT, () => {
+            handlerRef.current?.(() => {
+                NativeWindows.interceptQuit(false);
+                NativeWindows.quit?.();
+            });
+        });
+        return () => {
+            // Stop intercepting on the way out, for the reason the window half
+            // does: an app that stopped listening and went on refusing every quit
+            // would be a process that cannot be quit at all, which is worse than
+            // the bug this prevents.
+            NativeWindows.interceptQuit(false);
+            subscription.remove();
+        };
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [wanted, ...deps]);
+}
+/** Ends the application, asking nobody. */
+function quit() {
+    NativeWindows?.quit?.();
+}
+//# sourceMappingURL=quitRequest.js.map

package/dist/src/quitRequest.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"quitRequest.js","sourceRoot":"","sources":["../../src/quitRequest.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmCH,wCAmCC;AAGD,oBAEC;AAzED,6CAA+B;AAE/B,+CAAqE;AAgBrE,MAAM,aAAa,GAAG,kCAAmB,CAAC,GAAG,CAAsB,eAAe,CAAC,CAAC;AAEpF,iEAAiE;AACjE,MAAM,oBAAoB,GAAG,qBAAqB,CAAC;AAEnD,iDAAiD;AACpC,QAAA,WAAW,GAAG,aAAa,EAAE,aAAa,IAAI,IAAI,CAAC;AAEhE;;;;;;GAMG;AACH,SAAgB,cAAc,CAC5B,OAA8C,EAC9C,OAA+B,EAAE;IAEjC,MAAM,UAAU,GAAG,KAAK,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;IACzC,UAAU,CAAC,OAAO,GAAG,OAAO,CAAC;IAE7B,MAAM,MAAM,GAAG,OAAO,IAAI,IAAI,CAAC;IAE/B,KAAK,CAAC,SAAS,CAAC,GAAG,EAAE;QACnB,IAAI,CAAC,mBAAW,IAAI,CAAC,MAAM,EAAE,CAAC;YAC5B,OAAO;QACT,CAAC;QACD,uEAAuE;QACvE,sEAAsE;QACtE,UAAU;QACV,aAAc,CAAC,aAAc,CAAC,IAAI,CAAC,CAAC;QAEpC,MAAM,YAAY,GAAG,iCAAkB,CAAC,WAAW,CAAC,oBAAoB,EAAE,GAAG,EAAE;YAC7E,UAAU,CAAC,OAAO,EAAE,CAAC,GAAG,EAAE;gBACxB,aAAc,CAAC,aAAc,CAAC,KAAK,CAAC,CAAC;gBACrC,aAAc,CAAC,IAAI,EAAE,EAAE,CAAC;YAC1B,CAAC,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;QAEH,OAAO,GAAG,EAAE;YACV,mEAAmE;YACnE,sEAAsE;YACtE,qEAAqE;YACrE,yBAAyB;YACzB,aAAc,CAAC,aAAc,CAAC,KAAK,CAAC,CAAC;YACrC,YAAY,CAAC,MAAM,EAAE,CAAC;QACxB,CAAC,CAAC;QACF,uDAAuD;IACzD,CAAC,EAAE,CAAC,MAAM,EAAE,GAAG,IAAI,CAAC,CAAC,CAAC;AACxB,CAAC;AAED,2CAA2C;AAC3C,SAAgB,IAAI;IAClB,aAAa,EAAE,IAAI,EAAE,EAAE,CAAC;AAC1B,CAAC"}

package/dist/src/resourcePath.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Where the files the build put beside this application are.
+ *
+ * `Foo.app/Contents/Resources` on macOS, and beside the executable on Linux and
+ * Windows, which have no separate resources directory. A development run, where
+ * the host starts out of a build directory, answers that directory.
+ *
+ * Here rather than worked out by each app: this project's packager is what
+ * decides the layout, so an app deriving it would be an app that has to know
+ * the shape of a bundle it did not build. See native/core/AppPaths.h.
+ *
+ * Empty when the running executable's path cannot be determined, which no
+ * supported desktop does.
+ *
+ * @format
+ */
+export declare function resourcePath(): string;
+//# sourceMappingURL=resourcePath.d.ts.map

package/dist/src/resourcePath.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resourcePath.d.ts","sourceRoot":"","sources":["../../src/resourcePath.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAaH,wBAAgB,YAAY,IAAI,MAAM,CAOrC"}

package/dist/src/resourcePath.js

@@ -0,0 +1,31 @@
+"use strict";
+/**
+ * Where the files the build put beside this application are.
+ *
+ * `Foo.app/Contents/Resources` on macOS, and beside the executable on Linux and
+ * Windows, which have no separate resources directory. A development run, where
+ * the host starts out of a build directory, answers that directory.
+ *
+ * Here rather than worked out by each app: this project's packager is what
+ * decides the layout, so an app deriving it would be an app that has to know
+ * the shape of a bundle it did not build. See native/core/AppPaths.h.
+ *
+ * Empty when the running executable's path cannot be determined, which no
+ * supported desktop does.
+ *
+ * @format
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resourcePath = resourcePath;
+const react_native_1 = require("react-native");
+const NativeApp = react_native_1.TurboModuleRegistry.get('BasaltApp');
+let cached = null;
+function resourcePath() {
+    // Cached because it cannot change while the process runs, and an app reading
+    // it per file would otherwise cross the bridge each time.
+    if (cached == null) {
+        cached = NativeApp?.getResourcePath() ?? '';
+    }
+    return cached;
+}
+//# sourceMappingURL=resourcePath.js.map

package/dist/src/resourcePath.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resourcePath.js","sourceRoot":"","sources":["../../src/resourcePath.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;GAeG;;AAaH,oCAOC;AAlBD,+CAAiD;AAOjD,MAAM,SAAS,GAAG,kCAAmB,CAAC,GAAG,CAAkB,WAAW,CAAC,CAAC;AAExE,IAAI,MAAM,GAAkB,IAAI,CAAC;AAEjC,SAAgB,YAAY;IAC1B,6EAA6E;IAC7E,0DAA0D;IAC1D,IAAI,MAAM,IAAI,IAAI,EAAE,CAAC;QACnB,MAAM,GAAG,SAAS,EAAE,eAAe,EAAE,IAAI,EAAE,CAAC;IAC9C,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC"}

package/dist/src/responseBody.d.ts

@@ -0,0 +1,76 @@
+/**
+ * What the platform actually delivered for a `blob` response, and how to make a
+ * Blob out of it.
+ *
+ * `src/overrides/setUpXHR.ts` asks for `arraybuffer` when JavaScript asked for
+ * `blob`, because React Native's XHR turns that into a native request for
+ * `base64` -- and base64 is the only response encoding ReactCxxPlatform has that
+ * can carry arbitrary bytes through a JavaScript string intact.
+ *
+ * **Except that it only encodes on some versions.** `encodeResponseBody` is a
+ * fix that landed in ReactCxxPlatform's NetworkingModule after 0.86; before it,
+ * `didReceiveNetworkData` passes the body through whatever was asked for. And
+ * ReactCxxPlatform is fetched at the app's exact React Native version -- see
+ * native/bootstrap.sh for why one vendored copy cannot serve several -- so both
+ * behaviours are live at once across supported versions, and neither the app nor
+ * this package chooses which.
+ *
+ * Handing a raw body to `BlobModule.createFromParts` as `base64` is what the
+ * failure looked like: the decoder skips the characters that are not in the
+ * alphabet and returns whatever the rest happens to mean, so a 98-byte JSON body
+ * became one byte, or none. `fetch(...).json()` then failed with "JSON Parse
+ * error: Unexpected character: v" -- a complaint about a byte that appears
+ * nowhere in the response, which is a long way from the cause. Found in kino,
+ * where every call to its daemon failed this way.
+ *
+ * So the delivered string is examined rather than assumed.
+ *
+ * **One observation settles it.** Whether the platform encodes is a property of
+ * the build, not of a response, so it is learned rather than re-decided. A body
+ * that *cannot* be base64 -- one containing a character outside the alphabet, or
+ * a length that is not a multiple of four -- proves the platform does not
+ * encode, and that verdict holds for every response afterwards. A platform that
+ * does encode never produces such a body, so the verdict can only ever be
+ * reached correctly.
+ *
+ * **Content-Length settles it outright, when there is one.** The delivered
+ * string is either the body or its base64, and those have different lengths, so
+ * a byte count from the server picks one. That is exact and needs nothing
+ * learned. It is not always available -- a chunked response has no
+ * Content-Length, and kino's daemon sends every response chunked -- which is why
+ * it is a shortcut rather than the whole answer.
+ *
+ * **The window where it can still be wrong, stated.** With no Content-Length and
+ * nothing yet learned, a body that looks like canonical base64 is taken as
+ * base64. Most bodies are decisive: any JSON object or array contains `{`, `"`
+ * or `,`. A few are not -- `null`, `true` and `1234` are all four characters
+ * from the alphabet -- so a non-encoding platform whose *first* blob response is
+ * chunked *and* one of those is read wrongly, once.
+ *
+/** One part for `BlobModule.createFromParts`, with the size the Blob should claim. */
+export interface ResponseBlobPart {
+    part: {
+        data: string;
+        type: 'base64' | 'string';
+    };
+    size: number;
+    /** False when the platform did not encode, which the caller reports once. */
+    encoded: boolean;
+}
+/**
+ * Canonical base64: four-character groups from the alphabet, with at most two
+ * `=` and only at the end.
+ */
+export declare function looksLikeBase64(value: string): boolean;
+/** The number of bytes `value` is as UTF-8, which is what a Blob's size means. */
+export declare function utf8Length(value: string): number;
+/** The decoded length of canonical base64, from its length and padding alone. */
+export declare function base64Length(encoded: string): number;
+/**
+ * A reader that remembers what it has learned about this platform.
+ *
+ * One per process in the override; a factory rather than module state so that a
+ * test can start from not knowing.
+ */
+export declare function createResponseBodyReader(): (delivered: string, contentLength?: number | null) => ResponseBlobPart;
+//# sourceMappingURL=responseBody.d.ts.map

package/dist/src/responseBody.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"responseBody.d.ts","sourceRoot":"","sources":["../../src/responseBody.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sFAiDsF;AACtF,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,QAAQ,GAAG,QAAQ,CAAA;KAAC,CAAC;IAChD,IAAI,EAAE,MAAM,CAAC;IACb,6EAA6E;IAC7E,OAAO,EAAE,OAAO,CAAC;CAClB;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAKtD;AAED,kFAAkF;AAClF,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAiBhD;AAED,iFAAiF;AACjF,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAGpD;AAED;;;;;GAKG;AACH,wBAAgB,wBAAwB,IAAI,CAC1C,SAAS,EAAE,MAAM,EACjB,aAAa,CAAC,EAAE,MAAM,GAAG,IAAI,KAC1B,gBAAgB,CA8CpB"}

package/dist/src/responseBody.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.looksLikeBase64 = looksLikeBase64;
+exports.utf8Length = utf8Length;
+exports.base64Length = base64Length;
+exports.createResponseBodyReader = createResponseBodyReader;
+/**
+ * Canonical base64: four-character groups from the alphabet, with at most two
+ * `=` and only at the end.
+ */
+function looksLikeBase64(value) {
+    if (value.length === 0 || value.length % 4 !== 0) {
+        return false;
+    }
+    return /^[A-Za-z0-9+/]+={0,2}$/.test(value);
+}
+/** The number of bytes `value` is as UTF-8, which is what a Blob's size means. */
+function utf8Length(value) {
+    let bytes = 0;
+    for (let i = 0; i < value.length; i++) {
+        const code = value.charCodeAt(i);
+        if (code < 0x80) {
+            bytes += 1;
+        }
+        else if (code < 0x800) {
+            bytes += 2;
+        }
+        else if (code >= 0xd800 && code <= 0xdbff) {
+            // A surrogate pair is one character of four bytes; skip its low half.
+            bytes += 4;
+            i++;
+        }
+        else {
+            bytes += 3;
+        }
+    }
+    return bytes;
+}
+/** The decoded length of canonical base64, from its length and padding alone. */
+function base64Length(encoded) {
+    const padding = encoded.endsWith('==') ? 2 : encoded.endsWith('=') ? 1 : 0;
+    return Math.max(0, (encoded.length / 4) * 3 - padding);
+}
+/**
+ * A reader that remembers what it has learned about this platform.
+ *
+ * One per process in the override; a factory rather than module state so that a
+ * test can start from not knowing.
+ */
+function createResponseBodyReader() {
+    // null while nothing decisive has been seen.
+    let platformEncodes = null;
+    return function read(delivered, contentLength) {
+        const couldBeBase64 = looksLikeBase64(delivered);
+        if (!couldBeBase64 && delivered.length > 0) {
+            // Decisive: a platform that encodes could not have produced this.
+            platformEncodes = false;
+        }
+        // A byte count from the server, where there is one, decides it outright --
+        // and teaches the same lesson for the responses that arrive without one.
+        //
+        // Never from an empty body: base64 of no bytes is the empty string, so the
+        // two possibilities are identical and there is nothing to learn. Worth
+        // stating because `looksLikeBase64('')` is false, which would otherwise read
+        // as "this platform does not encode".
+        if (typeof contentLength === 'number' && contentLength >= 0 && delivered.length > 0) {
+            const rawFits = utf8Length(delivered) === contentLength;
+            const base64Fits = couldBeBase64 && base64Length(delivered) === contentLength;
+            // Only when exactly one fits. An empty body fits both, and says nothing.
+            if (rawFits !== base64Fits) {
+                platformEncodes = base64Fits;
+            }
+        }
+        // Unknown counts as encoding, because on a platform that does, every body
+        // looks like base64 and nothing decisive ever arrives.
+        const asBase64 = couldBeBase64 && platformEncodes !== false;
+        if (asBase64) {
+            return {
+                part: { data: delivered, type: 'base64' },
+                size: base64Length(delivered),
+                encoded: true,
+            };
+        }
+        // The body itself. Correct for a text body, which is what almost every
+        // `fetch(...).json()` is; a binary body was already damaged before it
+        // reached here, because it crossed into JavaScript as a string.
+        return {
+            part: { data: delivered, type: 'string' },
+            size: utf8Length(delivered),
+            encoded: false,
+        };
+    };
+}
+//# sourceMappingURL=responseBody.js.map

package/dist/src/responseBody.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"responseBody.js","sourceRoot":"","sources":["../../src/responseBody.ts"],"names":[],"mappings":"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"}

package/dist/src/responseHeaders.d.ts

@@ -0,0 +1,40 @@
+/**
+ * The response headers, in the shape React Native's XMLHttpRequest expects.
+ *
+ * ReactCxxPlatform's NetworkingModule holds them as
+ * `std::vector<std::pair<std::string, std::string>>` and bridges that straight
+ * to JavaScript, which makes an array of two-element arrays:
+ *
+ *     [["Content-Type", "application/json"], ["Content-Length", "580"]]
+ *
+ * React Native's XHR expects an object. `setResponseHeaders` does
+ * `Object.keys(headers)` to build its lower-cased lookup, so an array gives it
+ * the keys "0", "1", "2" and values that are arrays. Nothing throws: the headers
+ * are all there, correctly, and every lookup misses.
+ *
+ * What that looked like: `getResponseHeader('content-type')` null on a response
+ * that plainly had one, `fetch(...).headers.get(...)` null for everything, and
+ * `getAllResponseHeaders()` returning lines like `0: Server,BaseHTTP/0.6`. So a
+ * `Response` carried no content type, which is also why a Blob built from one
+ * had `type: ''`.
+ *
+ * Converted here rather than reported, because nothing about it is ambiguous and
+ * no app can act on it.
+ *
+ * **Duplicates are joined with ", "**, which is what the XHR specification says
+ * `getResponseHeader` returns for a header that appeared more than once, and
+ * what iOS and Android already hand over -- they build the object natively. The
+ * one header this is wrong for is `Set-Cookie`, which may not be joined; it is
+ * also the one header XHR refuses to return at all, so nothing here can reach
+ * it either way.
+ */
+export type DeliveredHeaders = ReadonlyArray<readonly [string, string]> | Record<string, string>;
+/** True for the array-of-pairs shape ReactCxxPlatform sends. */
+export declare function isHeaderPairs(value: unknown): value is ReadonlyArray<readonly [string, string]>;
+/**
+ * An object of header names to values. Anything already an object is passed
+ * through untouched, so a ReactCxxPlatform that starts sending one needs no
+ * change here.
+ */
+export declare function headersToObject(delivered: unknown): Record<string, string> | null;
+//# sourceMappingURL=responseHeaders.d.ts.map

package/dist/src/responseHeaders.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"responseHeaders.d.ts","sourceRoot":"","sources":["../../src/responseHeaders.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAEH,MAAM,MAAM,gBAAgB,GAAG,aAAa,CAAC,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;AAEjG,gEAAgE;AAChE,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,aAAa,CAAC,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAE/F;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,SAAS,EAAE,OAAO,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI,CAgCjF"}

package/dist/src/responseHeaders.js

@@ -0,0 +1,75 @@
+"use strict";
+/**
+ * The response headers, in the shape React Native's XMLHttpRequest expects.
+ *
+ * ReactCxxPlatform's NetworkingModule holds them as
+ * `std::vector<std::pair<std::string, std::string>>` and bridges that straight
+ * to JavaScript, which makes an array of two-element arrays:
+ *
+ *     [["Content-Type", "application/json"], ["Content-Length", "580"]]
+ *
+ * React Native's XHR expects an object. `setResponseHeaders` does
+ * `Object.keys(headers)` to build its lower-cased lookup, so an array gives it
+ * the keys "0", "1", "2" and values that are arrays. Nothing throws: the headers
+ * are all there, correctly, and every lookup misses.
+ *
+ * What that looked like: `getResponseHeader('content-type')` null on a response
+ * that plainly had one, `fetch(...).headers.get(...)` null for everything, and
+ * `getAllResponseHeaders()` returning lines like `0: Server,BaseHTTP/0.6`. So a
+ * `Response` carried no content type, which is also why a Blob built from one
+ * had `type: ''`.
+ *
+ * Converted here rather than reported, because nothing about it is ambiguous and
+ * no app can act on it.
+ *
+ * **Duplicates are joined with ", "**, which is what the XHR specification says
+ * `getResponseHeader` returns for a header that appeared more than once, and
+ * what iOS and Android already hand over -- they build the object natively. The
+ * one header this is wrong for is `Set-Cookie`, which may not be joined; it is
+ * also the one header XHR refuses to return at all, so nothing here can reach
+ * it either way.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isHeaderPairs = isHeaderPairs;
+exports.headersToObject = headersToObject;
+/** True for the array-of-pairs shape ReactCxxPlatform sends. */
+function isHeaderPairs(value) {
+    return Array.isArray(value);
+}
+/**
+ * An object of header names to values. Anything already an object is passed
+ * through untouched, so a ReactCxxPlatform that starts sending one needs no
+ * change here.
+ */
+function headersToObject(delivered) {
+    if (delivered == null) {
+        return null;
+    }
+    if (!isHeaderPairs(delivered)) {
+        return delivered;
+    }
+    const headers = {};
+    for (const pair of delivered) {
+        // Defensive about the pair rather than the array: this is parsing something
+        // that crossed a bridge, and a malformed entry should be skipped rather than
+        // become the string "undefined".
+        if (!Array.isArray(pair) || pair.length < 2) {
+            continue;
+        }
+        const [name, value] = pair;
+        if (typeof name !== 'string' || typeof value !== 'string') {
+            continue;
+        }
+        // Case-insensitively the same header, so that a server sending `Vary` and
+        // `vary` produces one entry rather than two that shadow each other.
+        const existing = Object.keys(headers).find(key => key.toLowerCase() === name.toLowerCase());
+        if (existing === undefined) {
+            headers[name] = value;
+        }
+        else {
+            headers[existing] = `${headers[existing]}, ${value}`;
+        }
+    }
+    return headers;
+}
+//# sourceMappingURL=responseHeaders.js.map

package/dist/src/responseHeaders.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"responseHeaders.js","sourceRoot":"","sources":["../../src/responseHeaders.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;;AAKH,sCAEC;AAOD,0CAgCC;AA1CD,gEAAgE;AAChE,SAAgB,aAAa,CAAC,KAAc;IAC1C,OAAO,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;AAC9B,CAAC;AAED;;;;GAIG;AACH,SAAgB,eAAe,CAAC,SAAkB;IAChD,IAAI,SAAS,IAAI,IAAI,EAAE,CAAC;QACtB,OAAO,IAAI,CAAC;IACd,CAAC;IACD,IAAI,CAAC,aAAa,CAAC,SAAS,CAAC,EAAE,CAAC;QAC9B,OAAO,SAAmC,CAAC;IAC7C,CAAC;IAED,MAAM,OAAO,GAA2B,EAAE,CAAC;IAC3C,KAAK,MAAM,IAAI,IAAI,SAAS,EAAE,CAAC;QAC7B,4EAA4E;QAC5E,6EAA6E;QAC7E,iCAAiC;QACjC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YAC5C,SAAS;QACX,CAAC;QACD,MAAM,CAAC,IAAI,EAAE,KAAK,CAAC,GAAG,IAAI,CAAC;QAC3B,IAAI,OAAO,IAAI,KAAK,QAAQ,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;YAC1D,SAAS;QACX,CAAC;QACD,0EAA0E;QAC1E,oEAAoE;QACpE,MAAM,QAAQ,GAAG,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,IAAI,CACxC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,WAAW,EAAE,KAAK,IAAI,CAAC,WAAW,EAAE,CAChD,CAAC;QACF,IAAI,QAAQ,KAAK,SAAS,EAAE,CAAC;YAC3B,OAAO,CAAC,IAAI,CAAC,GAAG,KAAK,CAAC;QACxB,CAAC;aAAM,CAAC;YACN,OAAO,CAAC,QAAQ,CAAC,GAAG,GAAG,OAAO,CAAC,QAAQ,CAAC,KAAK,KAAK,EAAE,CAAC;QACvD,CAAC;IACH,CAAC;IACD,OAAO,OAAO,CAAC;AACjB,CAAC"}

package/dist/src/titleBarState.d.ts

@@ -0,0 +1,43 @@
+/**
+ * The title bar requests currently mounted, and what they add up to.
+ *
+ * Kept apart from TitleBar.tsx, with no React Native in it, so that it can be
+ * tested with nothing but Node -- this is the part with rules in it.
+ *
+ * Several screens may each ask for something, as they do of <StatusBar>, and
+ * the most recently mounted request wins. But key by key: a screen that only
+ * sets a title does not reset the colour an app shell underneath it set, and
+ * when it unmounts the shell's title comes back.
+ *
+ * @format
+ */
+export declare const TITLE_BAR_KEYS: readonly ["title", "style", "backgroundColor", "textColor", "borderColor"];
+export type TitleBarKey = (typeof TITLE_BAR_KEYS)[number];
+/** The system's title bar, or none and the app draws its own. */
+export type TitleBarStyle = 'native' | 'hidden';
+/**
+ * A colour as React Native accepts one -- a string, or the number
+ * `processColor` produces. Deliberately not React Native's `ColorValue`: this
+ * file has no React Native in it, which is what lets it be tested under plain
+ * Node.
+ */
+export type TitleBarColor = string | number | null;
+export type TitleBarOptions = {
+    title?: string | null;
+    style?: TitleBarStyle;
+    backgroundColor?: TitleBarColor;
+    textColor?: TitleBarColor;
+    borderColor?: TitleBarColor;
+};
+/** What a stack of requests resolves to: the same keys, none of them required. */
+export type TitleBarRequest = TitleBarOptions;
+export type TitleBarStack = {
+    push(options?: TitleBarOptions | null): number;
+    update(id: number, options?: TitleBarOptions | null): void;
+    remove(id: number): void;
+    resolve(): TitleBarRequest;
+    readonly size: number;
+};
+export declare function createTitleBarStack(): TitleBarStack;
+export declare function sameRequest(a?: TitleBarRequest | null, b?: TitleBarRequest | null): boolean;
+//# sourceMappingURL=titleBarState.d.ts.map

package/dist/src/titleBarState.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"titleBarState.d.ts","sourceRoot":"","sources":["../../src/titleBarState.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,eAAO,MAAM,cAAc,4EAMjB,CAAC;AAEX,MAAM,MAAM,WAAW,GAAG,CAAC,OAAO,cAAc,CAAC,CAAC,MAAM,CAAC,CAAC;AAE1D,iEAAiE;AACjE,MAAM,MAAM,aAAa,GAAG,QAAQ,GAAG,QAAQ,CAAC;AAEhD;;;;;GAKG;AACH,MAAM,MAAM,aAAa,GAAG,MAAM,GAAG,MAAM,GAAG,IAAI,CAAC;AAEnD,MAAM,MAAM,eAAe,GAAG;IAC5B,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,KAAK,CAAC,EAAE,aAAa,CAAC;IACtB,eAAe,CAAC,EAAE,aAAa,CAAC;IAChC,SAAS,CAAC,EAAE,aAAa,CAAC;IAC1B,WAAW,CAAC,EAAE,aAAa,CAAC;CAC7B,CAAC;AAEF,kFAAkF;AAClF,MAAM,MAAM,eAAe,GAAG,eAAe,CAAC;AAE9C,MAAM,MAAM,aAAa,GAAG;IAC1B,IAAI,CAAC,OAAO,CAAC,EAAE,eAAe,GAAG,IAAI,GAAG,MAAM,CAAC;IAC/C,MAAM,CAAC,EAAE,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,eAAe,GAAG,IAAI,GAAG,IAAI,CAAC;IAC3D,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,OAAO,IAAI,eAAe,CAAC;IAC3B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB,CAAC;AAeF,wBAAgB,mBAAmB,IAAI,aAAa,CAsCnD;AAID,wBAAgB,WAAW,CACzB,CAAC,CAAC,EAAE,eAAe,GAAG,IAAI,EAC1B,CAAC,CAAC,EAAE,eAAe,GAAG,IAAI,GACzB,OAAO,CAET"}