basalt-core 0.0.0-rc5

package/dist/src/useDisplays.js

@@ -0,0 +1,118 @@
+"use strict";
+/**
+ * What screens the desktop has, where they are, and how dense they are.
+ *
+ * React Native's `Dimensions` reports the *window*, which is the right answer
+ * to a different question. An app placing a window, or deciding how much it
+ * can show, is asking about the screen it is on and the ones beside it.
+ *
+ * ## What each desktop will and will not say
+ *
+ * Bounds and scale factor: everywhere. The work area -- what is left after a
+ * menu bar, taskbar or dock -- comes from macOS and Windows, and GTK 4 has no
+ * way to ask, so it reports the full bounds there. The pointer's position
+ * comes from macOS and Windows and never from GTK.
+ *
+ * None of those are gaps waiting to be filled. `gdk_monitor_get_workarea`,
+ * `gdk_display_get_primary_monitor` and reading the pointer were all in GTK 3
+ * and were removed: Wayland has no protocol a client can use for any of them.
+ * See native/gtk/GtkWindowControl.cpp.
+ *
+ * So an app that needs the work area should treat "equal to bounds" as the
+ * answer rather than as a failure, and one that needs the pointer should check
+ * `known`.
+ *
+ * @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.displays = displays;
+exports.pointerPosition = pointerPosition;
+exports.useDisplays = useDisplays;
+exports.primaryDisplay = primaryDisplay;
+const React = __importStar(require("react"));
+const react_native_1 = require("react-native");
+const NativeWindows = react_native_1.TurboModuleRegistry.get('BasaltWindows');
+// Must match kDisplaysChangedEvent in native/core/WindowsModule.h.
+const DISPLAYS_CHANGED_EVENT = 'basaltDisplaysChanged';
+/** Whether this platform can be asked at all. */
+exports.isSupported = NativeWindows?.getDisplays != null;
+/**
+ * Every display, primary first.
+ *
+ * Synchronous, because the host keeps the list up to date rather than the
+ * platform asking the toolkit on demand -- see core/WindowControl.h. Empty
+ * before the host has reported anything, which an app can distinguish from
+ * "no displays" only by there being no such desktop.
+ */
+function displays() {
+    const found = NativeWindows?.getDisplays?.();
+    return Array.isArray(found) ? found : [];
+}
+/** Where the pointer is. A promise: nothing reports the pointer moving. */
+function pointerPosition() {
+    return (NativeWindows?.getPointerPosition?.() ??
+        Promise.resolve({ x: 0, y: 0, known: false }));
+}
+/**
+ * The displays, kept current.
+ *
+ * Re-reads whenever a monitor is plugged in, unplugged or rearranged. The
+ * event carries no payload for a reason -- several changes can arrive
+ * together, and re-reading is the only way to be right about all of them.
+ */
+function useDisplays() {
+    const [current, setCurrent] = React.useState(displays);
+    React.useEffect(() => {
+        if (!exports.isSupported) {
+            return;
+        }
+        // Once on mount as well as on every change: the list may have changed
+        // between the first render and this effect.
+        setCurrent(displays());
+        const subscription = react_native_1.DeviceEventEmitter.addListener(DISPLAYS_CHANGED_EVENT, () => {
+            setCurrent(displays());
+        });
+        return () => subscription.remove();
+    }, []);
+    return current;
+}
+/** The primary display, or null on a platform with none to report. */
+function primaryDisplay() {
+    const found = displays();
+    return found.find(display => display.primary) ?? found[0] ?? null;
+}
+//# sourceMappingURL=useDisplays.js.map

package/dist/src/useDisplays.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDisplays.js","sourceRoot":"","sources":["../../src/useDisplays.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkDH,4BAGC;AAGD,0CAKC;AASD,kCAkBC;AAGD,wCAGC;AA5FD,6CAA+B;AAE/B,+CAAqE;AA8BrE,MAAM,aAAa,GAAG,kCAAmB,CAAC,GAAG,CAAsB,eAAe,CAAC,CAAC;AAEpF,mEAAmE;AACnE,MAAM,sBAAsB,GAAG,uBAAuB,CAAC;AAEvD,iDAAiD;AACpC,QAAA,WAAW,GAAG,aAAa,EAAE,WAAW,IAAI,IAAI,CAAC;AAE9D;;;;;;;GAOG;AACH,SAAgB,QAAQ;IACtB,MAAM,KAAK,GAAG,aAAa,EAAE,WAAW,EAAE,EAAE,CAAC;IAC7C,OAAO,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC;AAC3C,CAAC;AAED,2EAA2E;AAC3E,SAAgB,eAAe;IAC7B,OAAO,CACL,aAAa,EAAE,kBAAkB,EAAE,EAAE;QACrC,OAAO,CAAC,OAAO,CAAC,EAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,KAAK,EAAC,CAAC,CAC5C,CAAC;AACJ,CAAC;AAED;;;;;;GAMG;AACH,SAAgB,WAAW;IACzB,MAAM,CAAC,OAAO,EAAE,UAAU,CAAC,GAAG,KAAK,CAAC,QAAQ,CAAY,QAAQ,CAAC,CAAC;IAElE,KAAK,CAAC,SAAS,CAAC,GAAG,EAAE;QACnB,IAAI,CAAC,mBAAW,EAAE,CAAC;YACjB,OAAO;QACT,CAAC;QACD,sEAAsE;QACtE,4CAA4C;QAC5C,UAAU,CAAC,QAAQ,EAAE,CAAC,CAAC;QAEvB,MAAM,YAAY,GAAG,iCAAkB,CAAC,WAAW,CAAC,sBAAsB,EAAE,GAAG,EAAE;YAC/E,UAAU,CAAC,QAAQ,EAAE,CAAC,CAAC;QACzB,CAAC,CAAC,CAAC;QACH,OAAO,GAAG,EAAE,CAAC,YAAY,CAAC,MAAM,EAAE,CAAC;IACrC,CAAC,EAAE,EAAE,CAAC,CAAC;IAEP,OAAO,OAAO,CAAC;AACjB,CAAC;AAED,sEAAsE;AACtE,SAAgB,cAAc;IAC5B,MAAM,KAAK,GAAG,QAAQ,EAAE,CAAC;IACzB,OAAO,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC,OAAO,CAAC,OAAO,CAAC,IAAI,KAAK,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC;AACpE,CAAC"}

package/dist/src/useHandledKeys.d.ts

@@ -0,0 +1,38 @@
+/**
+ * The half of `<KeyHandler>` that is not a component.
+ *
+ * Extracted so that the `View` override can use the same implementation rather
+ * than a second copy of it: a view that declares `keyDownEvents` and a
+ * `<KeyHandler>` are two spellings of one thing, and two spellings that drifted
+ * apart would be worse than either.
+ *
+ * @format
+ */
+/** A combination a view claims. Modifiers left out are required to be absent. */
+export interface HandledKey {
+    key: string;
+    altKey?: boolean;
+    ctrlKey?: boolean;
+    metaKey?: boolean;
+    shiftKey?: boolean;
+}
+/** What a press reports. The same shape, which is why they compare directly. */
+export type PressedKey = HandledKey;
+/** The event the host emits for a press a view claimed. */
+export declare const KEY_EVENT = "basaltKey";
+/**
+ * Registers `keys` for whatever `ref` points at, and calls `onPress` when one
+ * of them is pressed there.
+ *
+ * `keys` is compared by identity: an app that rebuilds its list every render
+ * re-registers every render, which is correct and cheap. One that memoises does
+ * not. `onPress` is read through a ref, so changing the handler does not
+ * re-register anything -- the native side only wants the list.
+ *
+ * Does nothing when `keys` is absent, which is how the `View` override can call
+ * it unconditionally and pay almost nothing for the views that do not use it.
+ */
+export declare function useHandledKeys(ref: {
+    current: unknown;
+}, keys: ReadonlyArray<HandledKey> | undefined, onPress: ((pressed: PressedKey) => void) | undefined): void;
+//# sourceMappingURL=useHandledKeys.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useHandledKeys.d.ts","sourceRoot":"","sources":["../../src/useHandledKeys.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAMH,iFAAiF;AACjF,MAAM,WAAW,UAAU;IACzB,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED,gFAAgF;AAChF,MAAM,MAAM,UAAU,GAAG,UAAU,CAAC;AASpC,2DAA2D;AAC3D,eAAO,MAAM,SAAS,cAAc,CAAC;AAKrC;;;;;;;;;;;GAWG;AACH,wBAAgB,cAAc,CAC5B,GAAG,EAAE;IAAC,OAAO,EAAE,OAAO,CAAA;CAAC,EACvB,IAAI,EAAE,aAAa,CAAC,UAAU,CAAC,GAAG,SAAS,EAC3C,OAAO,EAAE,CAAC,CAAC,OAAO,EAAE,UAAU,KAAK,IAAI,CAAC,GAAG,SAAS,GACnD,IAAI,CA0CN"}

package/dist/src/useHandledKeys.js

@@ -0,0 +1,70 @@
+"use strict";
+/**
+ * The half of `<KeyHandler>` that is not a component.
+ *
+ * Extracted so that the `View` override can use the same implementation rather
+ * than a second copy of it: a view that declares `keyDownEvents` and a
+ * `<KeyHandler>` are two spellings of one thing, and two spellings that drifted
+ * apart would be worse than either.
+ *
+ * @format
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KEY_EVENT = void 0;
+exports.useHandledKeys = useHandledKeys;
+const react_1 = require("react");
+const react_native_1 = require("react-native");
+const windows = react_native_1.TurboModuleRegistry.get('BasaltWindows');
+/** The event the host emits for a press a view claimed. */
+exports.KEY_EVENT = 'basaltKey';
+/**
+ * Registers `keys` for whatever `ref` points at, and calls `onPress` when one
+ * of them is pressed there.
+ *
+ * `keys` is compared by identity: an app that rebuilds its list every render
+ * re-registers every render, which is correct and cheap. One that memoises does
+ * not. `onPress` is read through a ref, so changing the handler does not
+ * re-register anything -- the native side only wants the list.
+ *
+ * Does nothing when `keys` is absent, which is how the `View` override can call
+ * it unconditionally and pay almost nothing for the views that do not use it.
+ */
+function useHandledKeys(ref, keys, onPress) {
+    const handler = (0, react_1.useRef)(onPress);
+    handler.current = onPress;
+    (0, react_1.useEffect)(() => {
+        // `__nativeTag`, with two underscores: that is the new renderer's name for
+        // it, and `_nativeTag` is undefined there. `<DropTarget>` learned the same.
+        const tag = ref.current?.__nativeTag;
+        if (keys == null || tag == null || windows == null) {
+            return;
+        }
+        windows.setHandledKeys(tag, keys);
+        return () => windows.clearHandledKeys(tag);
+    }, [keys, ref]);
+    (0, react_1.useEffect)(() => {
+        if (keys == null) {
+            return;
+        }
+        const subscription = react_native_1.DeviceEventEmitter.addListener(exports.KEY_EVENT, (event) => {
+            const tag = ref.current?.__nativeTag;
+            // By tag, because every listener in the app hears every event: the
+            // emitter is one channel and the host has already chosen which view the
+            // key belongs to.
+            if (tag == null || event.tag !== tag) {
+                return;
+            }
+            handler.current?.({
+                key: event.key,
+                altKey: event.altKey,
+                ctrlKey: event.ctrlKey,
+                metaKey: event.metaKey,
+                shiftKey: event.shiftKey,
+            });
+        });
+        return () => subscription.remove();
+        // Whether there are keys at all decides if this listens; which keys they
+        // are does not, because the host has already matched by the time it emits.
+    }, [keys == null, ref]);
+}
+//# sourceMappingURL=useHandledKeys.js.map

package/dist/src/useHandledKeys.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useHandledKeys.js","sourceRoot":"","sources":["../../src/useHandledKeys.ts"],"names":[],"mappings":";AAAA;;;;;;;;;GASG;;;AA2CH,wCA8CC;AAvFD,iCAAwC;AACxC,+CAAqE;AAoBrE,MAAM,OAAO,GAAG,kCAAmB,CAAC,GAAG,CAAsB,eAAe,CAAC,CAAC;AAE9E,2DAA2D;AAC9C,QAAA,SAAS,GAAG,WAAW,CAAC;AAKrC;;;;;;;;;;;GAWG;AACH,SAAgB,cAAc,CAC5B,GAAuB,EACvB,IAA2C,EAC3C,OAAoD;IAEpD,MAAM,OAAO,GAAG,IAAA,cAAM,EAAC,OAAO,CAAC,CAAC;IAChC,OAAO,CAAC,OAAO,GAAG,OAAO,CAAC;IAE1B,IAAA,iBAAS,EAAC,GAAG,EAAE;QACb,2EAA2E;QAC3E,4EAA4E;QAC5E,MAAM,GAAG,GAAI,GAAG,CAAC,OAAuB,EAAE,WAAW,CAAC;QACtD,IAAI,IAAI,IAAI,IAAI,IAAI,GAAG,IAAI,IAAI,IAAI,OAAO,IAAI,IAAI,EAAE,CAAC;YACnD,OAAO;QACT,CAAC;QACD,OAAO,CAAC,cAAc,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC;QAClC,OAAO,GAAG,EAAE,CAAC,OAAO,CAAC,gBAAgB,CAAC,GAAG,CAAC,CAAC;IAC7C,CAAC,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC,CAAC;IAEhB,IAAA,iBAAS,EAAC,GAAG,EAAE;QACb,IAAI,IAAI,IAAI,IAAI,EAAE,CAAC;YACjB,OAAO;QACT,CAAC;QACD,MAAM,YAAY,GAAG,iCAAkB,CAAC,WAAW,CACjD,iBAAS,EACT,CAAC,KAAkC,EAAE,EAAE;YACrC,MAAM,GAAG,GAAI,GAAG,CAAC,OAAuB,EAAE,WAAW,CAAC;YACtD,mEAAmE;YACnE,wEAAwE;YACxE,kBAAkB;YAClB,IAAI,GAAG,IAAI,IAAI,IAAI,KAAK,CAAC,GAAG,KAAK,GAAG,EAAE,CAAC;gBACrC,OAAO;YACT,CAAC;YACD,OAAO,CAAC,OAAO,EAAE,CAAC;gBAChB,GAAG,EAAE,KAAK,CAAC,GAAG;gBACd,MAAM,EAAE,KAAK,CAAC,MAAM;gBACpB,OAAO,EAAE,KAAK,CAAC,OAAO;gBACtB,OAAO,EAAE,KAAK,CAAC,OAAO;gBACtB,QAAQ,EAAE,KAAK,CAAC,QAAQ;aACzB,CAAC,CAAC;QACL,CAAC,CACF,CAAC;QACF,OAAO,GAAG,EAAE,CAAC,YAAY,CAAC,MAAM,EAAE,CAAC;QACnC,yEAAyE;QACzE,2EAA2E;IAC7E,CAAC,EAAE,CAAC,IAAI,IAAI,IAAI,EAAE,GAAG,CAAC,CAAC,CAAC;AAC1B,CAAC"}

package/dist/src/useWindow.d.ts

@@ -0,0 +1,140 @@
+/**
+ * The window: how big it is, where it is, and what it is doing.
+ *
+ *   const window = useWindow();
+ *
+ *   window.setSize(900, 700);
+ *   window.setPosition(100, 100);
+ *   window.center();
+ *   window.setFullScreen(true);
+ *   window.minimize();
+ *   window.toggleMaximize();
+ *   window.close();
+ *
+ *   const {width, height, x, y, fullScreen, maximized} = window.bounds;
+ *
+ * React Native has no API for any of this: on a phone there is one window, it
+ * is the screen, and nothing an app says would change it. On a desktop it is
+ * the first thing an app wants after it has drawn something.
+ *
+ * ## `bounds` is live
+ *
+ * It re-renders when the window moves, is resized, or changes state, because
+ * the alternative -- a `getBounds()` an app calls and caches -- is an app whose
+ * layout is right until somebody drags a corner. The host emits the change; see
+ * native/core/WindowMethods.h.
+ *
+ * Reading it before there is a window gives zeroes rather than null, so that
+ * `const {width} = window.bounds` never throws during a first render.
+ *
+ * ## What the platforms will not do
+ *
+ * `setPosition` and `center` do nothing on Linux, and `bounds.x` and `bounds.y`
+ * are always zero there. This is not unimplemented: GTK4 removed
+ * `gtk_window_move` and Wayland has no equivalent, because a client has no idea
+ * where its window is and no say in it. Both display servers centre an unplaced
+ * window by default, so an app that never moves its window already gets what
+ * `center()` would have asked for.
+ *
+ * Every other platform difference is spelling. `setSize` is a request on all
+ * three -- a tiling window manager may ignore it -- which is why `bounds`
+ * reports what happened rather than what was asked for.
+ *
+ * ## How big it may be, and where it sits
+ *
+ *   window.setMinimumSize(400, 300);
+ *   window.setMaximumSize(1200, 900);   // 0 in either direction clears a limit
+ *   window.setResizable(false);
+ *   window.setAlwaysOnTop(true);
+ *
+ * Two of these do nothing on Linux, and that is settled rather than pending:
+ * GTK4 removed `gtk_window_set_geometry_hints` and `gtk_window_set_keep_above`
+ * because Wayland has no protocol for either. So rather than have an app read
+ * this paragraph, `window.capabilities` answers:
+ *
+ *   {position, minimumSize, maximumSize, resizable, alwaysOnTop}
+ *
+ * all true on macOS and Windows; on Linux, `minimumSize` and `resizable`. An
+ * app can put its "always on top" switch away on the desktop that has no such
+ * thing, which is better than a switch that lies.
+ *
+ * ## Refusing to close
+ *
+ *   useCloseRequest(close => {
+ *     if (unsaved) {
+ *       setAsking(true);
+ *     } else {
+ *       close();
+ *     }
+ *   });
+ *
+ * A window with a close handler stops closing on its own: every attempt -- its
+ * close button, Cmd-W, Alt+F4, the window manager -- is refused and reported,
+ * and the window goes when the app says so by calling the `close` it was
+ * handed. Which is the point: there is nowhere else to put "are you sure".
+ *
+ * On macOS this covers closing the window and not Cmd-Q, which terminates the
+ * application without asking any window whether it minds.
+ *
+ * @format
+ */
+import type { CloseRequestHandler } from './closeRequest';
+export type { CloseRequestHandler, WindowId } from './closeRequest';
+/** Where the window is and how big, plus the two states that are not sizes. */
+export type WindowBounds = {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    fullScreen: boolean;
+    maximized: boolean;
+};
+/**
+ * What this desktop actually does, which is not the same list everywhere.
+ *
+ * All false where there is no window module, so an app that checks before
+ * offering a control gets the right answer rather than an exception.
+ */
+export type WindowCapabilities = {
+    position: boolean;
+    minimumSize: boolean;
+    maximumSize: boolean;
+    resizable: boolean;
+    alwaysOnTop: boolean;
+};
+/**
+ * The imperative half, usable outside a component.
+ *
+ * Every call is a no-op on a host with no window module, so the same code runs
+ * on a platform that has not implemented one.
+ */
+export declare const windowControl: Readonly<{
+    setSize(width: number, height: number): void;
+    setPosition(x: number, y: number): void;
+    center(): void;
+    setFullScreen(fullScreen?: boolean): void;
+    minimize(): void;
+    toggleMaximize(): void;
+    close(): void;
+    setMinimumSize(width: number, height: number): void;
+    setMaximumSize(width: number, height: number): void;
+    setResizable(resizable?: boolean): void;
+    setAlwaysOnTop(alwaysOnTop?: boolean): void;
+    getBounds(): WindowBounds;
+    getCapabilities(): WindowCapabilities;
+}>;
+/**
+ * Be asked before this window closes.
+ *
+ * Pass null or nothing to stop being asked, which is also what unmounting does.
+ * See the header above, and `<Window onCloseRequest>` for a second window.
+ */
+export declare function useCloseRequest(handler?: CloseRequestHandler | null): void;
+export type WindowControl = typeof windowControl;
+/** What the hook returns: the imperative surface, plus live state. */
+export type UseWindow = WindowControl & {
+    bounds: WindowBounds;
+    capabilities: WindowCapabilities;
+};
+export declare function useWindow(): UseWindow;
+//# sourceMappingURL=useWindow.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useWindow.d.ts","sourceRoot":"","sources":["../../src/useWindow.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+EG;AASH,OAAO,KAAK,EAAC,mBAAmB,EAAC,MAAM,gBAAgB,CAAC;AAExD,YAAY,EAAC,mBAAmB,EAAE,QAAQ,EAAC,MAAM,gBAAgB,CAAC;AAElE,+EAA+E;AAC/E,MAAM,MAAM,YAAY,GAAG;IACzB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,OAAO,CAAC;IACpB,SAAS,EAAE,OAAO,CAAC;CACpB,CAAC;AAEF;;;;;GAKG;AACH,MAAM,MAAM,kBAAkB,GAAG;IAC/B,QAAQ,EAAE,OAAO,CAAC;IAClB,WAAW,EAAE,OAAO,CAAC;IACrB,WAAW,EAAE,OAAO,CAAC;IACrB,SAAS,EAAE,OAAO,CAAC;IACnB,WAAW,EAAE,OAAO,CAAC;CACtB,CAAC;AAgEF;;;;;GAKG;AACH,eAAO,MAAM,aAAa;mBACT,MAAM,UAAU,MAAM,GAAG,IAAI;mBAG7B,MAAM,KAAK,MAAM,GAAG,IAAI;cAG7B,IAAI;+BAGa,OAAO,GAAG,IAAI;gBAG7B,IAAI;sBAGE,IAAI;aAGb,IAAI;0BAGS,MAAM,UAAU,MAAM,GAAG,IAAI;0BAG7B,MAAM,UAAU,MAAM,GAAG,IAAI;6BAG1B,OAAO,GAAG,IAAI;iCAGV,OAAO,GAAG,IAAI;iBAG9B,YAAY;uBAGN,kBAAkB;EAKrC,CAAC;AAEH;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,OAAO,CAAC,EAAE,mBAAmB,GAAG,IAAI,GAAG,IAAI,CAE1E;AAED,MAAM,MAAM,aAAa,GAAG,OAAO,aAAa,CAAC;AAEjD,sEAAsE;AACtE,MAAM,MAAM,SAAS,GAAG,aAAa,GAAG;IACtC,MAAM,EAAE,YAAY,CAAC;IACrB,YAAY,EAAE,kBAAkB,CAAC;CAClC,CAAC;AAEF,wBAAgB,SAAS,IAAI,SAAS,CAmBrC"}

package/dist/src/useWindow.js

@@ -0,0 +1,233 @@
+/**
+ * The window: how big it is, where it is, and what it is doing.
+ *
+ *   const window = useWindow();
+ *
+ *   window.setSize(900, 700);
+ *   window.setPosition(100, 100);
+ *   window.center();
+ *   window.setFullScreen(true);
+ *   window.minimize();
+ *   window.toggleMaximize();
+ *   window.close();
+ *
+ *   const {width, height, x, y, fullScreen, maximized} = window.bounds;
+ *
+ * React Native has no API for any of this: on a phone there is one window, it
+ * is the screen, and nothing an app says would change it. On a desktop it is
+ * the first thing an app wants after it has drawn something.
+ *
+ * ## `bounds` is live
+ *
+ * It re-renders when the window moves, is resized, or changes state, because
+ * the alternative -- a `getBounds()` an app calls and caches -- is an app whose
+ * layout is right until somebody drags a corner. The host emits the change; see
+ * native/core/WindowMethods.h.
+ *
+ * Reading it before there is a window gives zeroes rather than null, so that
+ * `const {width} = window.bounds` never throws during a first render.
+ *
+ * ## What the platforms will not do
+ *
+ * `setPosition` and `center` do nothing on Linux, and `bounds.x` and `bounds.y`
+ * are always zero there. This is not unimplemented: GTK4 removed
+ * `gtk_window_move` and Wayland has no equivalent, because a client has no idea
+ * where its window is and no say in it. Both display servers centre an unplaced
+ * window by default, so an app that never moves its window already gets what
+ * `center()` would have asked for.
+ *
+ * Every other platform difference is spelling. `setSize` is a request on all
+ * three -- a tiling window manager may ignore it -- which is why `bounds`
+ * reports what happened rather than what was asked for.
+ *
+ * ## How big it may be, and where it sits
+ *
+ *   window.setMinimumSize(400, 300);
+ *   window.setMaximumSize(1200, 900);   // 0 in either direction clears a limit
+ *   window.setResizable(false);
+ *   window.setAlwaysOnTop(true);
+ *
+ * Two of these do nothing on Linux, and that is settled rather than pending:
+ * GTK4 removed `gtk_window_set_geometry_hints` and `gtk_window_set_keep_above`
+ * because Wayland has no protocol for either. So rather than have an app read
+ * this paragraph, `window.capabilities` answers:
+ *
+ *   {position, minimumSize, maximumSize, resizable, alwaysOnTop}
+ *
+ * all true on macOS and Windows; on Linux, `minimumSize` and `resizable`. An
+ * app can put its "always on top" switch away on the desktop that has no such
+ * thing, which is better than a switch that lies.
+ *
+ * ## Refusing to close
+ *
+ *   useCloseRequest(close => {
+ *     if (unsaved) {
+ *       setAsking(true);
+ *     } else {
+ *       close();
+ *     }
+ *   });
+ *
+ * A window with a close handler stops closing on its own: every attempt -- its
+ * close button, Cmd-W, Alt+F4, the window manager -- is refused and reported,
+ * and the window goes when the app says so by calling the `close` it was
+ * handed. Which is the point: there is nowhere else to put "are you sure".
+ *
+ * On macOS this covers closing the window and not Cmd-Q, which terminates the
+ * application without asking any window whether it minds.
+ *
+ * @format
+ */
+'use strict';
+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.windowControl = void 0;
+exports.useCloseRequest = useCloseRequest;
+exports.useWindow = useWindow;
+const React = __importStar(require("react"));
+const react_native_1 = require("react-native");
+const closeRequest_1 = require("./closeRequest");
+const NativeWindow = react_native_1.TurboModuleRegistry.get('BasaltWindow');
+// Must match kWindowBoundsEvent in native/core/WindowMethods.h.
+const BOUNDS_EVENT = 'basaltWindowBoundsChanged';
+const NO_BOUNDS = Object.freeze({
+    x: 0,
+    y: 0,
+    width: 0,
+    height: 0,
+    fullScreen: false,
+    maximized: false,
+});
+// What this desktop actually does, which is not the same list everywhere.
+//
+// All false on a host with no window module, so an app that checks before
+// offering a control gets the right answer rather than an exception.
+const NO_CAPABILITIES = Object.freeze({
+    position: false,
+    minimumSize: false,
+    maximumSize: false,
+    resizable: false,
+    alwaysOnTop: false,
+});
+function readCapabilities() {
+    if (NativeWindow?.getCapabilities == null) {
+        return NO_CAPABILITIES;
+    }
+    return NativeWindow.getCapabilities() ?? NO_CAPABILITIES;
+}
+// Asked once. These are five booleans a platform knows at compile time, not a
+// question for the window manager, and re-reading them on every render would be
+// a JSI call per frame for an answer that cannot change.
+const capabilities = readCapabilities();
+function readBounds() {
+    if (NativeWindow?.getBounds == null) {
+        return NO_BOUNDS;
+    }
+    const bounds = NativeWindow.getBounds();
+    return bounds != null ? bounds : NO_BOUNDS;
+}
+/**
+ * The imperative half, usable outside a component.
+ *
+ * Every call is a no-op on a host with no window module, so the same code runs
+ * on a platform that has not implemented one.
+ */
+exports.windowControl = Object.freeze({
+    setSize(width, height) {
+        NativeWindow?.setSize?.(width, height);
+    },
+    setPosition(x, y) {
+        NativeWindow?.setPosition?.(x, y);
+    },
+    center() {
+        NativeWindow?.center?.();
+    },
+    setFullScreen(fullScreen) {
+        NativeWindow?.setFullScreen?.(fullScreen === true);
+    },
+    minimize() {
+        NativeWindow?.minimize?.();
+    },
+    toggleMaximize() {
+        NativeWindow?.toggleMaximize?.();
+    },
+    close() {
+        NativeWindow?.close?.();
+    },
+    setMinimumSize(width, height) {
+        NativeWindow?.setMinimumSize?.(width, height);
+    },
+    setMaximumSize(width, height) {
+        NativeWindow?.setMaximumSize?.(width, height);
+    },
+    setResizable(resizable) {
+        NativeWindow?.setResizable?.(resizable !== false);
+    },
+    setAlwaysOnTop(alwaysOnTop) {
+        NativeWindow?.setAlwaysOnTop?.(alwaysOnTop === true);
+    },
+    getBounds() {
+        return readBounds();
+    },
+    getCapabilities() {
+        // The cached answer, so that the imperative half and the hook cannot
+        // disagree about a thing that does not change.
+        return capabilities;
+    },
+});
+/**
+ * Be asked before this window closes.
+ *
+ * Pass null or nothing to stop being asked, which is also what unmounting does.
+ * See the header above, and `<Window onCloseRequest>` for a second window.
+ */
+function useCloseRequest(handler) {
+    (0, closeRequest_1.useCloseRequestFor)(closeRequest_1.mainWindowId, () => exports.windowControl.close(), handler, []);
+}
+function useWindow() {
+    const [bounds, setBounds] = React.useState(readBounds);
+    React.useEffect(() => {
+        // Read again on mount as well as subscribing. The window may have been
+        // resized between the first render and this effect -- which on a host that
+        // opens its window and mounts into it is the common case, not the rare one.
+        setBounds(readBounds());
+        const subscription = react_native_1.DeviceEventEmitter.addListener(BOUNDS_EVENT, (next) => {
+            setBounds(next ?? NO_BOUNDS);
+        });
+        return () => subscription.remove();
+    }, []);
+    return React.useMemo(() => ({ ...exports.windowControl, bounds, capabilities }), [bounds]);
+}
+//# sourceMappingURL=useWindow.js.map

package/dist/src/useWindow.js.map

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

package/dist/tsconfig.tsbuildinfo

@@ -0,0 +1 @@
+{"root":["../src/dragsource.tsx","../src/droptarget.tsx","../src/keyhandler.tsx","../src/menu.tsx","../src/titlebar.tsx","../src/window.tsx","../src/closerequest.ts","../src/globals.d.ts","../src/index.ts","../src/quitrequest.ts","../src/resourcepath.ts","../src/responsebody.ts","../src/responseheaders.ts","../src/titlebarstate.ts","../src/usecontextmenu.ts","../src/usedialog.ts","../src/usedisplays.ts","../src/usehandledkeys.ts","../src/usewindow.ts","../src/overrides/alert.ts","../src/overrides/baseviewconfig.ts","../src/overrides/platform.d.ts","../src/overrides/platform.linux.ts","../src/overrides/platform.macos.ts","../src/overrides/platform.windows.ts","../src/overrides/reactdevtoolssettingsmanager.ts","../src/overrides/refreshcontrol.tsx","../src/overrides/scrollview.tsx","../src/overrides/share.ts","../src/overrides/textinput.tsx","../src/overrides/view.tsx","../src/overrides/createplatform.ts","../src/overrides/setupdevelopertools.ts","../src/overrides/setupxhr.ts","../src/overrides/upstream.d.ts","../cli/basalt.ts","../cli/bundle-cli.ts","../cli/bundlewithassets.ts","../cli/desktop.ts","../cli/doctor.ts","../cli/init.ts","../cli/metro.ts","../cli/packageapp.ts","../cli/steps.ts","../react-native.config.js"],"version":"6.0.3"}