basalt-core 0.0.0-rc5

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

@@ -0,0 +1 @@
+{"version":3,"file":"Window.d.ts","sourceRoot":"","sources":["../../src/Window.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkEG;AAIH,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAK/B,OAAO,KAAK,EAAC,mBAAmB,EAAW,MAAM,gBAAgB,CAAC;AAElE,mFAAmF;AACnF,MAAM,MAAM,WAAW,GAAG;IACxB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC;IAC3B,0EAA0E;IAC1E,OAAO,CAAC,EAAE,MAAM,IAAI,CAAC;IACrB,2CAA2C;IAC3C,cAAc,CAAC,EAAE,mBAAmB,GAAG,IAAI,CAAC;CAC7C,CAAC;AAiBF,6DAA6D;AAC7D,eAAO,MAAM,WAAW,SAAwB,CAAC;AAyDjD,wBAAgB,MAAM,CAAC,EACrB,KAAK,EACL,KAAK,EACL,MAAM,EACN,QAAQ,EACR,OAAO,EACP,cAAc,GACf,EAAE,WAAW,GAAG,IAAI,CAwGpB;yBA/Ge,MAAM"}

package/dist/src/Window.js

@@ -0,0 +1,248 @@
+/**
+ * A second window.
+ *
+ *   <Window title="Preview" width={600} height={400} onClose={hide}>
+ *     <Preview id={id} />
+ *   </Window>
+ *
+ * Mount it and a window opens; unmount it and the window closes. React Native
+ * has no API for this because a phone has one window and it is the screen.
+ *
+ * ## A window is a React root
+ *
+ * That is Fabric's grain rather than a decision this makes: a surface is what
+ * has a size, a layout context and a root shadow node, and two windows sharing
+ * one would be two windows sharing a layout. So a second window runs a second
+ * React tree, and `<Window>`'s children are rendered *there* rather than where
+ * they were written.
+ *
+ * Which has a consequence worth stating plainly, because it is the one thing
+ * that will surprise people: **the children do not see React context from the
+ * tree they were written in.** A theme provider, a navigation container or a
+ * Redux store wrapping the `<Window>` is not wrapping its children. What does
+ * cross is props -- the elements themselves are passed through, so anything
+ * captured in a closure or given as a prop arrives intact, including state and
+ * callbacks:
+ *
+ *   const [count, setCount] = useState(0);
+ *   <Window><Text onPress={() => setCount(count + 1)}>{count}</Text></Window>
+ *
+ * works, and re-renders the window when `count` changes. A `useContext` inside
+ * `<Preview>` does not. An app that needs context in a window should pass the
+ * value as a prop and re-provide it inside.
+ *
+ * ## `onClose`
+ *
+ * Called when the *person* closed the window -- its own close button, or the
+ * window manager -- and not when the app unmounted the `<Window>`. An app that
+ * unmounted it already knows.
+ *
+ * It is the half that keeps the two sides agreeing: without it an app's `open`
+ * flag would stay true after the window had gone, the next render would try to
+ * close a window that closed itself, and the window could never be reopened.
+ *
+ * ## `onCloseRequest`
+ *
+ *   <Window onCloseRequest={close => (dirty ? ask() : close())}>
+ *
+ * The other half of `onClose`, and the earlier one: somebody is *trying* to
+ * close the window and it has not closed. A `<Window>` with this prop refuses
+ * every close the window manager asks for and reports the attempt instead, so
+ * the app can ask "are you sure".
+ *
+ * There are two ways to then say yes, and they are not the same one written
+ * twice. Unmounting the `<Window>` is the React-shaped one and usually right --
+ * the window is a render of some state, and agreeing to close it is that state
+ * changing. The `close` the handler is handed is the other, for when the app
+ * has no such state to change, and it closes the window without `onClose`,
+ * because an app that just said yes is not waiting to be told.
+ *
+ * `onClose` is unaffected by any of this: it still means the person closed the
+ * window, which now only happens when there is no handler to refuse it.
+ *
+ * `useWindow()` inside a second window's tree still reports the *active*
+ * window, not the one it is in; that is a real gap and is in docs/BACKLOG.md.
+ *
+ * @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.isSupported = void 0;
+exports.Window = Window;
+const React = __importStar(require("react"));
+const react_native_1 = require("react-native");
+const closeRequest_1 = require("./closeRequest");
+const NativeWindows = react_native_1.TurboModuleRegistry.get('BasaltWindows');
+/** Whether this platform can open a second window at all. */
+exports.isSupported = NativeWindows != null;
+// What each open window is rendering, by the id `<Window>` gave it, and who to
+// tell when it changes. Module level because the two ends are in different
+// React roots and have no ancestor in common -- which is the whole situation.
+// Must match kWindowClosedEvent in native/core/WindowsModule.h.
+const CLOSED_EVENT = 'basaltWindowClosed';
+const contents = new Map();
+const listeners = new Map();
+let nextId = 1;
+function setContent(id, children) {
+    contents.set(id, children);
+    const listener = listeners.get(id);
+    if (listener != null) {
+        listener(children);
+    }
+}
+/**
+ * The component every second window runs.
+ *
+ * Registered once, under a name an app will not collide with. It renders
+ * whatever its `<Window>` currently has as children, and subscribes so that a
+ * re-render of the first tree reaches the second.
+ */
+function WindowContent({ basaltWindowId }) {
+    const [children, setChildren] = React.useState(() => contents.get(basaltWindowId) ?? null);
+    React.useEffect(() => {
+        listeners.set(basaltWindowId, setChildren);
+        // Read again on mount: the first tree may have re-rendered between the
+        // window opening and this root evaluating, and the map is the truth.
+        setChildren(contents.get(basaltWindowId) ?? null);
+        return () => {
+            listeners.delete(basaltWindowId);
+        };
+    }, [basaltWindowId]);
+    return children;
+}
+const CONTENT_COMPONENT = 'BasaltWindowContent';
+let registered = false;
+function ensureRegistered() {
+    if (registered || !exports.isSupported) {
+        return;
+    }
+    registered = true;
+    react_native_1.AppRegistry.registerComponent(CONTENT_COMPONENT, () => WindowContent);
+}
+function Window({ title, width, height, children, onClose, onCloseRequest, }) {
+    const id = React.useRef(null);
+    if (id.current == null) {
+        id.current = nextId++;
+    }
+    const windowId = id.current;
+    // Written during render rather than in an effect, so that the second root
+    // never renders a frame behind the first. Rendering is not supposed to have
+    // effects; this one is a write to a map the other root reads, which is the
+    // narrowest version of what a portal does.
+    setContent(windowId, children);
+    // The surface id the host gave us, which is what closes the window. Kept in a
+    // ref rather than in state: nothing renders differently for it.
+    const surfaceId = React.useRef(null);
+    // And the same id in state, which `onCloseRequest` needs. A ref changing is
+    // not a render, and the intercept has to be registered once the host has
+    // answered with an id -- which is a promise later than the effect that asked
+    // for the window. Two homes for one number, because the two readers want
+    // different things from it.
+    const [opened, setOpened] = React.useState(null);
+    // In a ref so that the subscription below does not have to be torn down and
+    // rebuilt every time an app passes a new closure, which is every render.
+    const onCloseRef = React.useRef(onClose);
+    onCloseRef.current = onClose;
+    // Deliberately not depending on title, width or height. They are how a window
+    // *opens*, and re-opening one because its title changed would be a new window
+    // in a new place. Changing them afterwards is `useWindow()`'s job.
+    // Closed by the person rather than by the app -- its own close button, or the
+    // window manager. The window is already gone by the time this arrives; what
+    // it is for is telling the app, so its state stops saying the window is open.
+    //
+    // Without it the next render would try to close a window that closed itself,
+    // and an app whose `open` flag never cleared could never reopen one.
+    React.useEffect(() => {
+        if (!exports.isSupported) {
+            return;
+        }
+        const subscription = react_native_1.DeviceEventEmitter.addListener(CLOSED_EVENT, closedId => {
+            if (closedId !== surfaceId.current) {
+                return;
+            }
+            // Forgotten first, so the cleanup below does not ask the host to close a
+            // window that is already gone.
+            surfaceId.current = null;
+            setOpened(null);
+            if (onCloseRef.current != null) {
+                onCloseRef.current();
+            }
+        });
+        return () => subscription.remove();
+    }, []);
+    // Asked before it closes, if the app wants to be. See closeRequest.js.
+    (0, closeRequest_1.useCloseRequestFor)(() => opened, 
+    // `isSupported` is what proves the module is here.
+    (closing) => NativeWindows.close(closing), onCloseRequest, [opened]);
+    React.useEffect(() => {
+        if (!exports.isSupported) {
+            return;
+        }
+        ensureRegistered();
+        let closed = false;
+        NativeWindows.open({
+            component: CONTENT_COMPONENT,
+            title: title ?? '',
+            width: width ?? 900,
+            height: height ?? 700,
+            props: { basaltWindowId: windowId },
+        }).then((openedId) => {
+            // Unmounted while the window was opening, which is a race a fast app
+            // really does lose: close what was opened rather than leaking it.
+            if (closed) {
+                if (openedId != null) {
+                    NativeWindows.close(openedId);
+                }
+                return;
+            }
+            surfaceId.current = openedId;
+            setOpened(openedId);
+        });
+        return () => {
+            closed = true;
+            if (surfaceId.current != null) {
+                NativeWindows.close(surfaceId.current);
+                surfaceId.current = null;
+            }
+            contents.delete(windowId);
+            listeners.delete(windowId);
+        };
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [windowId]);
+    return null;
+}
+Window.isSupported = exports.isSupported;
+//# sourceMappingURL=Window.js.map

package/dist/src/Window.js.map

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

package/dist/src/closeRequest.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Being asked before a window closes.
+ *
+ * The shared half of `useCloseRequest()` and `<Window onCloseRequest>`: they
+ * are the same mechanism pointed at two different windows, and the only thing
+ * that differs is which id and how it closes.
+ *
+ * ## Why a registration rather than a returned `false`
+ *
+ * Electron spells this `event.preventDefault()` in a `close` handler, and can,
+ * because its handler runs in the main process and the answer is there the
+ * moment the event is raised. Here the handler is JavaScript on another thread
+ * and the window manager wants a synchronous yes or no -- so the decision has
+ * to exist *before* the attempt. Registering a handler is what makes it exist:
+ * the host then refuses every close and reports the attempt, and the app closes
+ * the window itself when it is ready.
+ *
+ * The cost is that a window with a handler never closes on its own, which is
+ * why the handler is given the thing that does.
+ *
+ * @format
+ */
+/** A window's id, as the host hands them out. */
+export type WindowId = number;
+/**
+ * What the handler is given: call it to let the close through. It stops
+ * intercepting first, so the close it then asks for is not refused by the
+ * registration that produced the question.
+ */
+export type AllowClose = () => void;
+export type CloseRequestHandler = (close: AllowClose) => void;
+/** Whether this platform can be asked at all. */
+export declare const isSupported: boolean;
+/**
+ * The window the app started in.
+ *
+ * Asked rather than assumed: `getWindows()` answers main window first, which is
+ * the same ordering the host keeps its records in. The fallback is the constant
+ * every host uses for it, for a platform with no windows module -- where the
+ * whole thing is a no-op anyway.
+ */
+export declare function mainWindowId(): WindowId;
+/**
+ * Ask to be asked, and hear about it.
+ *
+ * `getId` is a function rather than a number because a second window's id
+ * arrives from a promise: the hook may run before the window exists. Returning
+ * null means "not yet", and `deps` is what re-runs this once it is.
+ *
+ * `close` is what the handler is handed. It stops intercepting first, so that
+ * the close it then asks for is not refused by the registration that produced
+ * the question -- an app that answers "yes" once should not be asked again.
+ */
+export declare function useCloseRequestFor(getId: () => WindowId | null | undefined, close: (id: WindowId) => void, handler: CloseRequestHandler | null | undefined, deps: ReadonlyArray<unknown>): void;
+//# sourceMappingURL=closeRequest.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"closeRequest.d.ts","sourceRoot":"","sources":["../../src/closeRequest.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAMH,iDAAiD;AACjD,MAAM,MAAM,QAAQ,GAAG,MAAM,CAAC;AAE9B;;;;GAIG;AACH,MAAM,MAAM,UAAU,GAAG,MAAM,IAAI,CAAC;AAEpC,MAAM,MAAM,mBAAmB,GAAG,CAAC,KAAK,EAAE,UAAU,KAAK,IAAI,CAAC;AAY9D,iDAAiD;AACjD,eAAO,MAAM,WAAW,SAAwC,CAAC;AAEjE;;;;;;;GAOG;AACH,wBAAgB,YAAY,IAAI,QAAQ,CAGvC;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,MAAM,QAAQ,GAAG,IAAI,GAAG,SAAS,EACxC,KAAK,EAAE,CAAC,EAAE,EAAE,QAAQ,KAAK,IAAI,EAC7B,OAAO,EAAE,mBAAmB,GAAG,IAAI,GAAG,SAAS,EAC/C,IAAI,EAAE,aAAa,CAAC,OAAO,CAAC,GAC3B,IAAI,CAkDN"}

package/dist/src/closeRequest.js

@@ -0,0 +1,134 @@
+"use strict";
+/**
+ * Being asked before a window closes.
+ *
+ * The shared half of `useCloseRequest()` and `<Window onCloseRequest>`: they
+ * are the same mechanism pointed at two different windows, and the only thing
+ * that differs is which id and how it closes.
+ *
+ * ## Why a registration rather than a returned `false`
+ *
+ * Electron spells this `event.preventDefault()` in a `close` handler, and can,
+ * because its handler runs in the main process and the answer is there the
+ * moment the event is raised. Here the handler is JavaScript on another thread
+ * and the window manager wants a synchronous yes or no -- so the decision has
+ * to exist *before* the attempt. Registering a handler is what makes it exist:
+ * the host then refuses every close and reports the attempt, and the app closes
+ * the window itself when it is ready.
+ *
+ * The cost is that a window with a handler never closes on its own, which is
+ * why the handler is given the thing that does.
+ *
+ * @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.mainWindowId = mainWindowId;
+exports.useCloseRequestFor = useCloseRequestFor;
+const React = __importStar(require("react"));
+const react_native_1 = require("react-native");
+const NativeWindows = react_native_1.TurboModuleRegistry.get('BasaltWindows');
+// Must match kWindowCloseRequestedEvent in native/core/WindowsModule.h.
+const CLOSE_REQUESTED_EVENT = 'basaltWindowCloseRequested';
+/** Whether this platform can be asked at all. */
+exports.isSupported = NativeWindows?.interceptClose != null;
+/**
+ * The window the app started in.
+ *
+ * Asked rather than assumed: `getWindows()` answers main window first, which is
+ * the same ordering the host keeps its records in. The fallback is the constant
+ * every host uses for it, for a platform with no windows module -- where the
+ * whole thing is a no-op anyway.
+ */
+function mainWindowId() {
+    const open = NativeWindows?.getWindows?.();
+    return Array.isArray(open) && open.length > 0 ? open[0] : 1;
+}
+/**
+ * Ask to be asked, and hear about it.
+ *
+ * `getId` is a function rather than a number because a second window's id
+ * arrives from a promise: the hook may run before the window exists. Returning
+ * null means "not yet", and `deps` is what re-runs this once it is.
+ *
+ * `close` is what the handler is handed. It stops intercepting first, so that
+ * the close it then asks for is not refused by the registration that produced
+ * the question -- an app that answers "yes" once should not be asked again.
+ */
+function useCloseRequestFor(getId, close, handler, deps) {
+    const handlerRef = React.useRef(handler);
+    handlerRef.current = handler;
+    // In a ref for the same reason, and it matters less only because both callers
+    // pass something that closes over nothing. Reading it through a ref is what
+    // keeps that from being load-bearing.
+    const closeRef = React.useRef(close);
+    closeRef.current = close;
+    // Whether there is a handler at all, rather than which one. An app passes a
+    // new closure every render and re-registering on each would be a subscription
+    // torn down and rebuilt for nothing.
+    const wanted = handler != null;
+    React.useEffect(() => {
+        if (!exports.isSupported || !wanted) {
+            return;
+        }
+        const id = getId();
+        if (id == null) {
+            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.interceptClose(id, true);
+        const subscription = react_native_1.DeviceEventEmitter.addListener(CLOSE_REQUESTED_EVENT, (requestedId) => {
+            if (requestedId !== id) {
+                return;
+            }
+            handlerRef.current?.(() => {
+                NativeWindows.interceptClose(id, false);
+                closeRef.current(id);
+            });
+        });
+        return () => {
+            // Stop intercepting on the way out. A window whose app stopped listening
+            // and went on refusing every close would be a window that cannot be
+            // closed at all, which is a worse bug than the one this prevents.
+            NativeWindows.interceptClose(id, false);
+            subscription.remove();
+        };
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [wanted, ...deps]);
+}
+//# sourceMappingURL=closeRequest.js.map

package/dist/src/closeRequest.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"closeRequest.js","sourceRoot":"","sources":["../../src/closeRequest.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuCH,oCAGC;AAaD,gDAuDC;AA5GD,6CAA+B;AAE/B,+CAAqE;AAmBrE,MAAM,aAAa,GAAG,kCAAmB,CAAC,GAAG,CAAsB,eAAe,CAAC,CAAC;AAEpF,wEAAwE;AACxE,MAAM,qBAAqB,GAAG,4BAA4B,CAAC;AAE3D,iDAAiD;AACpC,QAAA,WAAW,GAAG,aAAa,EAAE,cAAc,IAAI,IAAI,CAAC;AAEjE;;;;;;;GAOG;AACH,SAAgB,YAAY;IAC1B,MAAM,IAAI,GAAG,aAAa,EAAE,UAAU,EAAE,EAAE,CAAC;IAC3C,OAAO,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AAC9D,CAAC;AAED;;;;;;;;;;GAUG;AACH,SAAgB,kBAAkB,CAChC,KAAwC,EACxC,KAA6B,EAC7B,OAA+C,EAC/C,IAA4B;IAE5B,MAAM,UAAU,GAAG,KAAK,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;IACzC,UAAU,CAAC,OAAO,GAAG,OAAO,CAAC;IAE7B,8EAA8E;IAC9E,4EAA4E;IAC5E,sCAAsC;IACtC,MAAM,QAAQ,GAAG,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;IACrC,QAAQ,CAAC,OAAO,GAAG,KAAK,CAAC;IAEzB,4EAA4E;IAC5E,8EAA8E;IAC9E,qCAAqC;IACrC,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,MAAM,EAAE,GAAG,KAAK,EAAE,CAAC;QACnB,IAAI,EAAE,IAAI,IAAI,EAAE,CAAC;YACf,OAAO;QACT,CAAC;QACD,uEAAuE;QACvE,sEAAsE;QACtE,UAAU;QACV,aAAc,CAAC,cAAe,CAAC,EAAE,EAAE,IAAI,CAAC,CAAC;QAEzC,MAAM,YAAY,GAAG,iCAAkB,CAAC,WAAW,CACjD,qBAAqB,EACrB,CAAC,WAAqB,EAAE,EAAE;YACxB,IAAI,WAAW,KAAK,EAAE,EAAE,CAAC;gBACvB,OAAO;YACT,CAAC;YACD,UAAU,CAAC,OAAO,EAAE,CAAC,GAAG,EAAE;gBACxB,aAAc,CAAC,cAAe,CAAC,EAAE,EAAE,KAAK,CAAC,CAAC;gBAC1C,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC;YACvB,CAAC,CAAC,CAAC;QACL,CAAC,CACF,CAAC;QAEF,OAAO,GAAG,EAAE;YACV,yEAAyE;YACzE,oEAAoE;YACpE,kEAAkE;YAClE,aAAc,CAAC,cAAe,CAAC,EAAE,EAAE,KAAK,CAAC,CAAC;YAC1C,YAAY,CAAC,MAAM,EAAE,CAAC;QACxB,CAAC,CAAC;QACF,uDAAuD;IACzD,CAAC,EAAE,CAAC,MAAM,EAAE,GAAG,IAAI,CAAC,CAAC,CAAC;AACxB,CAAC"}

package/dist/src/index.d.ts

@@ -0,0 +1,45 @@
+/**
+ * basalt-core
+ *
+ * What this platform adds to React Native, and nothing else. Components come
+ * from `react-native` exactly as they do on iOS and Android; this is where the
+ * few things with no React Native equivalent live.
+ *
+ * It used to re-export all of `react-native` as well, and that is worth saying
+ * why it no longer does, because the failure was quiet until something imported
+ * this file. Babel compiles `export * from 'react-native'` into a loop that
+ * reads every one of React Native's exports once -- and most of them are lazy
+ * getters, which run their module's top level when read. So importing this
+ * package loaded every deprecated component (and printed every deprecation
+ * warning), and loaded DevMenu, whose getEnforcing throws on a host with no
+ * DevMenu module. That throw aborted the importing module, which in an Expo app
+ * is App.js, and the app stopped at "App entry not found". Nothing had imported
+ * this file before the title bar gave apps a reason to.
+ *
+ * @format
+ */
+export { default as Platform } from './overrides/Platform';
+export { useDialog, dialog } from './useDialog';
+export { resourcePath } from './resourcePath';
+export type { Dialog, DialogFilter, DialogOptions, DialogResult } from './useDialog';
+export { Menu } from './Menu';
+export type { MenuItemProps, MenuProps, MenuRole, MenuSubmenuProps } from './Menu';
+export { useContextMenu, contextMenu } from './useContextMenu';
+export type { ContextMenu, ContextMenuItem, ContextMenuPoint } from './useContextMenu';
+export { Window } from './Window';
+export type { WindowProps } from './Window';
+export { useWindow, useCloseRequest, windowControl } from './useWindow';
+export { useQuitRequest, quit } from './quitRequest';
+export { useDisplays, displays, primaryDisplay, pointerPosition } from './useDisplays';
+export { DropTarget, dropTargetId } from './DropTarget';
+export { KeyHandler } from './KeyHandler';
+export { DragSource, dragSourceId } from './DragSource';
+export type { DragSourceProps } from './DragSource';
+export type { DropPayload, DropPoint, DropTargetProps } from './DropTarget';
+export type { HandledKey, KeyHandlerProps, PressedKey } from './KeyHandler';
+export type { Display, PointerPosition } from './useDisplays';
+export type { AllowQuit, QuitRequestHandler } from './quitRequest';
+export type { CloseRequestHandler, UseWindow, WindowBounds, WindowCapabilities, WindowControl, WindowId, } from './useWindow';
+export { TitleBar, useTitleBar, useTitleBarMetrics } from './TitleBar';
+export type { TitleBarMetrics, TitleBarOptions, TitleBarStyle } from './TitleBar';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAQH,OAAO,EAAC,OAAO,IAAI,QAAQ,EAAC,MAAM,sBAAsB,CAAC;AAGzD,OAAO,EAAC,SAAS,EAAE,MAAM,EAAC,MAAM,aAAa,CAAC;AAE9C,OAAO,EAAC,YAAY,EAAC,MAAM,gBAAgB,CAAC;AAC5C,YAAY,EAAC,MAAM,EAAE,YAAY,EAAE,aAAa,EAAE,YAAY,EAAC,MAAM,aAAa,CAAC;AAInF,OAAO,EAAC,IAAI,EAAC,MAAM,QAAQ,CAAC;AAC5B,YAAY,EAAC,aAAa,EAAE,SAAS,EAAE,QAAQ,EAAE,gBAAgB,EAAC,MAAM,QAAQ,CAAC;AAGjF,OAAO,EAAC,cAAc,EAAE,WAAW,EAAC,MAAM,kBAAkB,CAAC;AAC7D,YAAY,EAAC,WAAW,EAAE,eAAe,EAAE,gBAAgB,EAAC,MAAM,kBAAkB,CAAC;AAGrF,OAAO,EAAC,MAAM,EAAC,MAAM,UAAU,CAAC;AAChC,YAAY,EAAC,WAAW,EAAC,MAAM,UAAU,CAAC;AAI1C,OAAO,EAAC,SAAS,EAAE,eAAe,EAAE,aAAa,EAAC,MAAM,aAAa,CAAC;AAItE,OAAO,EAAC,cAAc,EAAE,IAAI,EAAC,MAAM,eAAe,CAAC;AAInD,OAAO,EAAC,WAAW,EAAE,QAAQ,EAAE,cAAc,EAAE,eAAe,EAAC,MAAM,eAAe,CAAC;AAIrF,OAAO,EAAC,UAAU,EAAE,YAAY,EAAC,MAAM,cAAc,CAAC;AAGtD,OAAO,EAAC,UAAU,EAAC,MAAM,cAAc,CAAC;AACxC,OAAO,EAAC,UAAU,EAAE,YAAY,EAAC,MAAM,cAAc,CAAC;AACtD,YAAY,EAAC,eAAe,EAAC,MAAM,cAAc,CAAC;AAClD,YAAY,EAAC,WAAW,EAAE,SAAS,EAAE,eAAe,EAAC,MAAM,cAAc,CAAC;AAC1E,YAAY,EAAC,UAAU,EAAE,eAAe,EAAE,UAAU,EAAC,MAAM,cAAc,CAAC;AAC1E,YAAY,EAAC,OAAO,EAAE,eAAe,EAAC,MAAM,eAAe,CAAC;AAC5D,YAAY,EAAC,SAAS,EAAE,kBAAkB,EAAC,MAAM,eAAe,CAAC;AACjE,YAAY,EACV,mBAAmB,EACnB,SAAS,EACT,YAAY,EACZ,kBAAkB,EAClB,aAAa,EACb,QAAQ,GACT,MAAM,aAAa,CAAC;AAGrB,OAAO,EAAC,QAAQ,EAAE,WAAW,EAAE,kBAAkB,EAAC,MAAM,YAAY,CAAC;AACrE,YAAY,EAAC,eAAe,EAAE,eAAe,EAAE,aAAa,EAAC,MAAM,YAAY,CAAC"}

package/dist/src/index.js

@@ -0,0 +1,92 @@
+/**
+ * basalt-core
+ *
+ * What this platform adds to React Native, and nothing else. Components come
+ * from `react-native` exactly as they do on iOS and Android; this is where the
+ * few things with no React Native equivalent live.
+ *
+ * It used to re-export all of `react-native` as well, and that is worth saying
+ * why it no longer does, because the failure was quiet until something imported
+ * this file. Babel compiles `export * from 'react-native'` into a loop that
+ * reads every one of React Native's exports once -- and most of them are lazy
+ * getters, which run their module's top level when read. So importing this
+ * package loaded every deprecated component (and printed every deprecation
+ * warning), and loaded DevMenu, whose getEnforcing throws on a host with no
+ * DevMenu module. That throw aborted the importing module, which in an Expo app
+ * is App.js, and the app stopped at "App entry not found". Nothing had imported
+ * this file before the title bar gave apps a reason to.
+ *
+ * @format
+ */
+'use strict';
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useTitleBarMetrics = exports.useTitleBar = exports.TitleBar = exports.dragSourceId = exports.DragSource = exports.KeyHandler = exports.dropTargetId = exports.DropTarget = exports.pointerPosition = exports.primaryDisplay = exports.displays = exports.useDisplays = exports.quit = exports.useQuitRequest = exports.windowControl = exports.useCloseRequest = exports.useWindow = exports.Window = exports.contextMenu = exports.useContextMenu = exports.Menu = exports.resourcePath = exports.dialog = exports.useDialog = exports.Platform = void 0;
+// Extensionless on purpose: Metro picks Platform.linux.js, Platform.macos.js or
+// Platform.windows.js by the platform being bundled for, which is the same
+// mechanism React Native uses for its own and means this line never has to know
+// how many desktops there are.
+var Platform_1 = require("./overrides/Platform");
+Object.defineProperty(exports, "Platform", { enumerable: true, get: function () { return __importDefault(Platform_1).default; } });
+// The native file dialogs, which React Native has no API for: a phone has none.
+// See useDialog.js.
+var useDialog_1 = require("./useDialog");
+Object.defineProperty(exports, "useDialog", { enumerable: true, get: function () { return useDialog_1.useDialog; } });
+Object.defineProperty(exports, "dialog", { enumerable: true, get: function () { return useDialog_1.dialog; } });
+// Where a packaged app's own files are; see resourcePath.ts.
+var resourcePath_1 = require("./resourcePath");
+Object.defineProperty(exports, "resourcePath", { enumerable: true, get: function () { return resourcePath_1.resourcePath; } });
+// The application menu. On macOS it is also what makes Cmd-C reach a text
+// field, which is why an app gets one whether or not it renders a <Menu>. See
+// Menu.js.
+var Menu_1 = require("./Menu");
+Object.defineProperty(exports, "Menu", { enumerable: true, get: function () { return Menu_1.Menu; } });
+// A context menu, which every desktop has -- including the one with no menu
+// bar. See useContextMenu.js.
+var useContextMenu_1 = require("./useContextMenu");
+Object.defineProperty(exports, "useContextMenu", { enumerable: true, get: function () { return useContextMenu_1.useContextMenu; } });
+Object.defineProperty(exports, "contextMenu", { enumerable: true, get: function () { return useContextMenu_1.contextMenu; } });
+// A second window, which is a second surface and so a second React root. See
+// Window.js for what that costs and what it does not.
+var Window_1 = require("./Window");
+Object.defineProperty(exports, "Window", { enumerable: true, get: function () { return Window_1.Window; } });
+// The window itself: its size, how big it may be, its position, whether it
+// fills the screen, live bounds, and being asked before it closes. See
+// useWindow.js.
+var useWindow_1 = require("./useWindow");
+Object.defineProperty(exports, "useWindow", { enumerable: true, get: function () { return useWindow_1.useWindow; } });
+Object.defineProperty(exports, "useCloseRequest", { enumerable: true, get: function () { return useWindow_1.useCloseRequest; } });
+Object.defineProperty(exports, "windowControl", { enumerable: true, get: function () { return useWindow_1.windowControl; } });
+// Being asked before the *application* quits, which the window half above
+// does not cover: see src/quitRequest.ts.
+var quitRequest_1 = require("./quitRequest");
+Object.defineProperty(exports, "useQuitRequest", { enumerable: true, get: function () { return quitRequest_1.useQuitRequest; } });
+Object.defineProperty(exports, "quit", { enumerable: true, get: function () { return quitRequest_1.quit; } });
+// What screens the desktop has, which React Native's Dimensions does not
+// answer: see src/useDisplays.ts.
+var useDisplays_1 = require("./useDisplays");
+Object.defineProperty(exports, "useDisplays", { enumerable: true, get: function () { return useDisplays_1.useDisplays; } });
+Object.defineProperty(exports, "displays", { enumerable: true, get: function () { return useDisplays_1.displays; } });
+Object.defineProperty(exports, "primaryDisplay", { enumerable: true, get: function () { return useDisplays_1.primaryDisplay; } });
+Object.defineProperty(exports, "pointerPosition", { enumerable: true, get: function () { return useDisplays_1.pointerPosition; } });
+// Accepting a file or text dragged onto the app, which React Native has no
+// API for: see src/DropTarget.tsx.
+var DropTarget_1 = require("./DropTarget");
+Object.defineProperty(exports, "DropTarget", { enumerable: true, get: function () { return DropTarget_1.DropTarget; } });
+Object.defineProperty(exports, "dropTargetId", { enumerable: true, get: function () { return DropTarget_1.dropTargetId; } });
+// Keyboard shortcuts on a view, which React Native has only inside a
+// <TextInput>. See src/KeyHandler.tsx.
+var KeyHandler_1 = require("./KeyHandler");
+Object.defineProperty(exports, "KeyHandler", { enumerable: true, get: function () { return KeyHandler_1.KeyHandler; } });
+var DragSource_1 = require("./DragSource");
+Object.defineProperty(exports, "DragSource", { enumerable: true, get: function () { return DragSource_1.DragSource; } });
+Object.defineProperty(exports, "dragSourceId", { enumerable: true, get: function () { return DragSource_1.dragSourceId; } });
+// The window's title bar: its title and colours, and a hidden style that lets
+// the app draw its own header. See TitleBar.js.
+var TitleBar_1 = require("./TitleBar");
+Object.defineProperty(exports, "TitleBar", { enumerable: true, get: function () { return TitleBar_1.TitleBar; } });
+Object.defineProperty(exports, "useTitleBar", { enumerable: true, get: function () { return TitleBar_1.useTitleBar; } });
+Object.defineProperty(exports, "useTitleBarMetrics", { enumerable: true, get: function () { return TitleBar_1.useTitleBarMetrics; } });
+//# sourceMappingURL=index.js.map

package/dist/src/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,YAAY,CAAC;;;;;;AAEb,gFAAgF;AAChF,2EAA2E;AAC3E,gFAAgF;AAChF,+BAA+B;AAC/B,iDAAyD;AAAjD,qHAAA,OAAO,OAAY;AAC3B,gFAAgF;AAChF,oBAAoB;AACpB,yCAA8C;AAAtC,sGAAA,SAAS,OAAA;AAAE,mGAAA,MAAM,OAAA;AACzB,6DAA6D;AAC7D,+CAA4C;AAApC,4GAAA,YAAY,OAAA;AAEpB,0EAA0E;AAC1E,8EAA8E;AAC9E,WAAW;AACX,+BAA4B;AAApB,4FAAA,IAAI,OAAA;AAEZ,4EAA4E;AAC5E,8BAA8B;AAC9B,mDAA6D;AAArD,gHAAA,cAAc,OAAA;AAAE,6GAAA,WAAW,OAAA;AAEnC,6EAA6E;AAC7E,sDAAsD;AACtD,mCAAgC;AAAxB,gGAAA,MAAM,OAAA;AAEd,2EAA2E;AAC3E,uEAAuE;AACvE,gBAAgB;AAChB,yCAAsE;AAA9D,sGAAA,SAAS,OAAA;AAAE,4GAAA,eAAe,OAAA;AAAE,0GAAA,aAAa,OAAA;AAEjD,0EAA0E;AAC1E,0CAA0C;AAC1C,6CAAmD;AAA3C,6GAAA,cAAc,OAAA;AAAE,mGAAA,IAAI,OAAA;AAE5B,yEAAyE;AACzE,kCAAkC;AAClC,6CAAqF;AAA7E,0GAAA,WAAW,OAAA;AAAE,uGAAA,QAAQ,OAAA;AAAE,6GAAA,cAAc,OAAA;AAAE,8GAAA,eAAe,OAAA;AAE9D,2EAA2E;AAC3E,mCAAmC;AACnC,2CAAsD;AAA9C,wGAAA,UAAU,OAAA;AAAE,0GAAA,YAAY,OAAA;AAChC,qEAAqE;AACrE,uCAAuC;AACvC,2CAAwC;AAAhC,wGAAA,UAAU,OAAA;AAClB,2CAAsD;AAA9C,wGAAA,UAAU,OAAA;AAAE,0GAAA,YAAY,OAAA;AAchC,8EAA8E;AAC9E,gDAAgD;AAChD,uCAAqE;AAA7D,oGAAA,QAAQ,OAAA;AAAE,uGAAA,WAAW,OAAA;AAAE,8GAAA,kBAAkB,OAAA"}