basalt-core 0.0.0-rc5

package/dist/src/titleBarState.js

@@ -0,0 +1,77 @@
+"use strict";
+/**
+ * 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
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TITLE_BAR_KEYS = void 0;
+exports.createTitleBarStack = createTitleBarStack;
+exports.sameRequest = sameRequest;
+exports.TITLE_BAR_KEYS = [
+    'title',
+    'style',
+    'backgroundColor',
+    'textColor',
+    'borderColor',
+];
+function pick(options) {
+    const picked = {};
+    for (const key of exports.TITLE_BAR_KEYS) {
+        if (options != null && options[key] !== undefined) {
+            // Each key's type is preserved by the assignment below; the index here is
+            // the one place the compiler cannot see that, because `key` ranges over
+            // the union.
+            picked[key] = options[key];
+        }
+    }
+    return picked;
+}
+function createTitleBarStack() {
+    const entries = [];
+    let nextId = 1;
+    return {
+        push(options) {
+            const id = nextId++;
+            entries.push({ id, options: pick(options) });
+            return id;
+        },
+        update(id, options) {
+            const entry = entries.find(candidate => candidate.id === id);
+            if (entry != null) {
+                entry.options = pick(options);
+            }
+        },
+        remove(id) {
+            const index = entries.findIndex(candidate => candidate.id === id);
+            if (index !== -1) {
+                entries.splice(index, 1);
+            }
+        },
+        // Later entries override earlier ones, one key at a time.
+        resolve() {
+            const resolved = {};
+            for (const { options } of entries) {
+                Object.assign(resolved, options);
+            }
+            return resolved;
+        },
+        get size() {
+            return entries.length;
+        },
+    };
+}
+// Whether two resolved requests would ask the host for the same thing, so that
+// a re-render that changed nothing does not cross into native at all.
+function sameRequest(a, b) {
+    return exports.TITLE_BAR_KEYS.every(key => (a ?? {})[key] === (b ?? {})[key]);
+}
+//# sourceMappingURL=titleBarState.js.map

package/dist/src/titleBarState.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"titleBarState.js","sourceRoot":"","sources":["../../src/titleBarState.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;GAYG;;;AAuDH,kDAsCC;AAID,kCAKC;AApGY,QAAA,cAAc,GAAG;IAC5B,OAAO;IACP,OAAO;IACP,iBAAiB;IACjB,WAAW;IACX,aAAa;CACL,CAAC;AAkCX,SAAS,IAAI,CAAC,OAAgC;IAC5C,MAAM,MAAM,GAAoB,EAAE,CAAC;IACnC,KAAK,MAAM,GAAG,IAAI,sBAAc,EAAE,CAAC;QACjC,IAAI,OAAO,IAAI,IAAI,IAAI,OAAO,CAAC,GAAG,CAAC,KAAK,SAAS,EAAE,CAAC;YAClD,0EAA0E;YAC1E,wEAAwE;YACxE,aAAa;YACZ,MAAuC,CAAC,GAAG,CAAC,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC;QAC/D,CAAC;IACH,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC;AAED,SAAgB,mBAAmB;IACjC,MAAM,OAAO,GAAkD,EAAE,CAAC;IAClE,IAAI,MAAM,GAAG,CAAC,CAAC;IAEf,OAAO;QACL,IAAI,CAAC,OAAgC;YACnC,MAAM,EAAE,GAAG,MAAM,EAAE,CAAC;YACpB,OAAO,CAAC,IAAI,CAAC,EAAC,EAAE,EAAE,OAAO,EAAE,IAAI,CAAC,OAAO,CAAC,EAAC,CAAC,CAAC;YAC3C,OAAO,EAAE,CAAC;QACZ,CAAC;QAED,MAAM,CAAC,EAAU,EAAE,OAAgC;YACjD,MAAM,KAAK,GAAG,OAAO,CAAC,IAAI,CAAC,SAAS,CAAC,EAAE,CAAC,SAAS,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC;YAC7D,IAAI,KAAK,IAAI,IAAI,EAAE,CAAC;gBAClB,KAAK,CAAC,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC;YAChC,CAAC;QACH,CAAC;QAED,MAAM,CAAC,EAAU;YACf,MAAM,KAAK,GAAG,OAAO,CAAC,SAAS,CAAC,SAAS,CAAC,EAAE,CAAC,SAAS,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC;YAClE,IAAI,KAAK,KAAK,CAAC,CAAC,EAAE,CAAC;gBACjB,OAAO,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;YAC3B,CAAC;QACH,CAAC;QAED,0DAA0D;QAC1D,OAAO;YACL,MAAM,QAAQ,GAAoB,EAAE,CAAC;YACrC,KAAK,MAAM,EAAC,OAAO,EAAC,IAAI,OAAO,EAAE,CAAC;gBAChC,MAAM,CAAC,MAAM,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC;YACnC,CAAC;YACD,OAAO,QAAQ,CAAC;QAClB,CAAC;QAED,IAAI,IAAI;YACN,OAAO,OAAO,CAAC,MAAM,CAAC;QACxB,CAAC;KACF,CAAC;AACJ,CAAC;AAED,+EAA+E;AAC/E,sEAAsE;AACtE,SAAgB,WAAW,CACzB,CAA0B,EAC1B,CAA0B;IAE1B,OAAO,sBAAc,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;AACxE,CAAC"}

package/dist/src/useContextMenu.d.ts

@@ -0,0 +1,113 @@
+/**
+ * A native context menu.
+ *
+ *   const menu = useContextMenu();
+ *
+ *   <Pressable
+ *     onLongPress={event =>
+ *       menu.show(
+ *         [
+ *           {label: 'Copy', onSelect: copy},
+ *           {separator: true},
+ *           {label: 'Delete', onSelect: remove, shortcut: 'Del'},
+ *           {label: 'Paste', enabled: false},
+ *         ],
+ *         event.nativeEvent,
+ *       )
+ *     }
+ *   />
+ *
+ * React Native has no API for this because a phone has no pointer to click the
+ * other button of. On a desktop it is the second thing an app wants after a
+ * menu bar -- and on Linux it is the *first*, because GNOME has no menu bar and
+ * `Menu.isSupported` is false there.
+ *
+ * ## One level, on purpose
+ *
+ * No submenus and no roles. A popup menu on all three desktops is a list, and
+ * the nesting an application menu has is what a menu *bar* is for -- so a
+ * `<Menu>` and this are different shapes rather than the same shape twice.
+ *
+ * ## Where it appears
+ *
+ * `show(items, where)` takes anything with an `x` and a `y` in the window's
+ * coordinates, which is what a press event's `nativeEvent` already is. Pass
+ * nothing and the menu opens wherever the pointer is, which is what a menu
+ * opened from the keyboard wants.
+ *
+ * ## What it answers
+ *
+ * `show()` resolves with the index chosen, or null if the menu was dismissed --
+ * and calls that item's `onSelect` first, which is what most callers want:
+ *
+ *   const chosen = await menu.show(items);
+ *
+ * A promise rather than the device event `<Menu>` uses, because the two are
+ * different situations. A menu bar is installed once and its items are chosen
+ * at times nothing is waiting for; a context menu is opened by an app that is,
+ * right then, asking a question.
+ *
+ * ## A right-click
+ *
+ *   <View
+ *     onPointerDown={e => e.nativeEvent.button === 2 && menu.show(items, e.nativeEvent)}
+ *   />
+ *
+ * A secondary click arrives as `onPointerDown` with W3C's `button === 2`, and
+ * does *not* fire `onPress` -- on any of the three. So the same view can be a
+ * button and have a context menu, which is what a desktop expects.
+ *
+ * `onLongPress` still works and is what a touch-first app should use. See
+ * native/core/PointerButtons.h for what each toolkit had to be told.
+ *
+ * @format
+ */
+/**
+ * One item in a context menu, as `native/core/MenuModel.h` reads it, plus the
+ * handler this file calls.
+ *
+ * `onSelect` is the only field the native side does not see: the promise
+ * carries the index back, and this calls the handler before settling it.
+ */
+export type ContextMenuItem = {
+    label?: string;
+    /** One of the platform roles; see native/core/MenuModel.h. */
+    role?: string;
+    /** "CmdOrCtrl+O", in Electron's spelling. Ignored for a role. */
+    accelerator?: string;
+    enabled?: boolean;
+    separator?: boolean;
+    submenu?: ReadonlyArray<ContextMenuItem>;
+    onSelect?: () => void;
+};
+/**
+ * Where to open it. A press event carries `pageX`/`pageY`; a caller with a
+ * point in hand carries `x`/`y`. Either, or neither for wherever the pointer
+ * is.
+ */
+export type ContextMenuPoint = {
+    x?: number;
+    y?: number;
+    pageX?: number;
+    pageY?: number;
+};
+/**
+ * Whether this platform can show one.
+ *
+ * True on all three, unlike `Menu.isSupported`: a menu bar is what GNOME does
+ * not have, and a popup menu is something every desktop has always had.
+ */
+export declare const isSupported: boolean;
+declare function show(items: ReadonlyArray<ContextMenuItem>, where?: ContextMenuPoint | null): Promise<number | null>;
+/**
+ * The imperative half, usable outside a component -- the same arrangement
+ * `useDialog()` and `windowControl` have.
+ */
+export declare const contextMenu: Readonly<{
+    show: typeof show;
+    isSupported: boolean;
+}>;
+export type ContextMenu = typeof contextMenu;
+export declare function useContextMenu(): ContextMenu;
+export {};
+//# sourceMappingURL=useContextMenu.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useContextMenu.d.ts","sourceRoot":"","sources":["../../src/useContextMenu.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+DG;AAKH;;;;;;GAMG;AACH,MAAM,MAAM,eAAe,GAAG;IAC5B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,8DAA8D;IAC9D,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,iEAAiE;IACjE,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,OAAO,CAAC,EAAE,aAAa,CAAC,eAAe,CAAC,CAAC;IACzC,QAAQ,CAAC,EAAE,MAAM,IAAI,CAAC;CACvB,CAAC;AAEF;;;;GAIG;AACH,MAAM,MAAM,gBAAgB,GAAG;IAC7B,CAAC,CAAC,EAAE,MAAM,CAAC;IACX,CAAC,CAAC,EAAE,MAAM,CAAC;IACX,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAYF;;;;;GAKG;AACH,eAAO,MAAM,WAAW,SAAsC,CAAC;AAE/D,iBAAe,IAAI,CACjB,KAAK,EAAE,aAAa,CAAC,eAAe,CAAC,EACrC,KAAK,CAAC,EAAE,gBAAgB,GAAG,IAAI,GAC9B,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAoBxB;AAED;;;GAGG;AACH,eAAO,MAAM,WAAW;;;EAAqC,CAAC;AAE9D,MAAM,MAAM,WAAW,GAAG,OAAO,WAAW,CAAC;AAE7C,wBAAgB,cAAc,IAAI,WAAW,CAK5C"}

package/dist/src/useContextMenu.js

@@ -0,0 +1,109 @@
+"use strict";
+/**
+ * A native context menu.
+ *
+ *   const menu = useContextMenu();
+ *
+ *   <Pressable
+ *     onLongPress={event =>
+ *       menu.show(
+ *         [
+ *           {label: 'Copy', onSelect: copy},
+ *           {separator: true},
+ *           {label: 'Delete', onSelect: remove, shortcut: 'Del'},
+ *           {label: 'Paste', enabled: false},
+ *         ],
+ *         event.nativeEvent,
+ *       )
+ *     }
+ *   />
+ *
+ * React Native has no API for this because a phone has no pointer to click the
+ * other button of. On a desktop it is the second thing an app wants after a
+ * menu bar -- and on Linux it is the *first*, because GNOME has no menu bar and
+ * `Menu.isSupported` is false there.
+ *
+ * ## One level, on purpose
+ *
+ * No submenus and no roles. A popup menu on all three desktops is a list, and
+ * the nesting an application menu has is what a menu *bar* is for -- so a
+ * `<Menu>` and this are different shapes rather than the same shape twice.
+ *
+ * ## Where it appears
+ *
+ * `show(items, where)` takes anything with an `x` and a `y` in the window's
+ * coordinates, which is what a press event's `nativeEvent` already is. Pass
+ * nothing and the menu opens wherever the pointer is, which is what a menu
+ * opened from the keyboard wants.
+ *
+ * ## What it answers
+ *
+ * `show()` resolves with the index chosen, or null if the menu was dismissed --
+ * and calls that item's `onSelect` first, which is what most callers want:
+ *
+ *   const chosen = await menu.show(items);
+ *
+ * A promise rather than the device event `<Menu>` uses, because the two are
+ * different situations. A menu bar is installed once and its items are chosen
+ * at times nothing is waiting for; a context menu is opened by an app that is,
+ * right then, asking a question.
+ *
+ * ## A right-click
+ *
+ *   <View
+ *     onPointerDown={e => e.nativeEvent.button === 2 && menu.show(items, e.nativeEvent)}
+ *   />
+ *
+ * A secondary click arrives as `onPointerDown` with W3C's `button === 2`, and
+ * does *not* fire `onPress` -- on any of the three. So the same view can be a
+ * button and have a context menu, which is what a desktop expects.
+ *
+ * `onLongPress` still works and is what a touch-first app should use. See
+ * native/core/PointerButtons.h for what each toolkit had to be told.
+ *
+ * @format
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.contextMenu = exports.isSupported = void 0;
+exports.useContextMenu = useContextMenu;
+const react_native_1 = require("react-native");
+const NativeMenu = react_native_1.TurboModuleRegistry.get('BasaltMenu');
+/**
+ * Whether this platform can show one.
+ *
+ * True on all three, unlike `Menu.isSupported`: a menu bar is what GNOME does
+ * not have, and a popup menu is something every desktop has always had.
+ */
+exports.isSupported = NativeMenu?.showContextMenu != null;
+async function show(items, where) {
+    if (!exports.isSupported || !Array.isArray(items) || items.length === 0) {
+        return null;
+    }
+    // Negative is "wherever the pointer is"; see the header. `pageX`/`pageY` as
+    // well as `x`/`y`, because a press event carries the first pair and a caller
+    // with a point in hand carries the second.
+    const x = where?.x ?? where?.pageX ?? -1;
+    const y = where?.y ?? where?.pageY ?? -1;
+    // `isSupported` is what proves this is non-null, and the compiler cannot see
+    // through that -- it is computed at module scope from the same optional call.
+    const index = await NativeMenu.showContextMenu(items, x, y);
+    if (index == null) {
+        return null;
+    }
+    // Called before the promise settles, so that an app which only wants
+    // `onSelect` never has to await anything.
+    items[index]?.onSelect?.();
+    return index;
+}
+/**
+ * The imperative half, usable outside a component -- the same arrangement
+ * `useDialog()` and `windowControl` have.
+ */
+exports.contextMenu = Object.freeze({ show, isSupported: exports.isSupported });
+function useContextMenu() {
+    // Frozen and module-level, so this is a stable identity rather than a new
+    // object every render: an app putting `menu` in a dependency array should not
+    // get a new one each time.
+    return exports.contextMenu;
+}
+//# sourceMappingURL=useContextMenu.js.map

package/dist/src/useContextMenu.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useContextMenu.js","sourceRoot":"","sources":["../../src/useContextMenu.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+DG;;;AAuFH,wCAKC;AAzFD,+CAAiD;AAyCjD,MAAM,UAAU,GAAG,kCAAmB,CAAC,GAAG,CAAmB,YAAY,CAAC,CAAC;AAE3E;;;;;GAKG;AACU,QAAA,WAAW,GAAG,UAAU,EAAE,eAAe,IAAI,IAAI,CAAC;AAE/D,KAAK,UAAU,IAAI,CACjB,KAAqC,EACrC,KAA+B;IAE/B,IAAI,CAAC,mBAAW,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAChE,OAAO,IAAI,CAAC;IACd,CAAC;IACD,4EAA4E;IAC5E,6EAA6E;IAC7E,2CAA2C;IAC3C,MAAM,CAAC,GAAG,KAAK,EAAE,CAAC,IAAI,KAAK,EAAE,KAAK,IAAI,CAAC,CAAC,CAAC;IACzC,MAAM,CAAC,GAAG,KAAK,EAAE,CAAC,IAAI,KAAK,EAAE,KAAK,IAAI,CAAC,CAAC,CAAC;IAEzC,6EAA6E;IAC7E,8EAA8E;IAC9E,MAAM,KAAK,GAAG,MAAM,UAAW,CAAC,eAAe,CAAC,KAAK,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;IAC7D,IAAI,KAAK,IAAI,IAAI,EAAE,CAAC;QAClB,OAAO,IAAI,CAAC;IACd,CAAC;IACD,qEAAqE;IACrE,0CAA0C;IAC1C,KAAK,CAAC,KAAK,CAAC,EAAE,QAAQ,EAAE,EAAE,CAAC;IAC3B,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;;GAGG;AACU,QAAA,WAAW,GAAG,MAAM,CAAC,MAAM,CAAC,EAAC,IAAI,EAAE,WAAW,EAAX,mBAAW,EAAC,CAAC,CAAC;AAI9D,SAAgB,cAAc;IAC5B,0EAA0E;IAC1E,8EAA8E;IAC9E,2BAA2B;IAC3B,OAAO,mBAAW,CAAC;AACrB,CAAC"}

package/dist/src/useDialog.d.ts

@@ -0,0 +1,98 @@
+/**
+ * The native file dialogs.
+ *
+ *   const dialog = useDialog();
+ *
+ *   const {canceled, paths} = await dialog.openFile({
+ *     title: 'Choose an image',
+ *     multiple: true,
+ *     filters: [{name: 'Images', extensions: ['png', 'jpg', 'jpeg']}],
+ *   });
+ *
+ *   const {canceled, paths: [path]} = await dialog.saveFile({
+ *     defaultPath: 'notes.md',
+ *   });
+ *
+ *   const {canceled, paths: [folder]} = await dialog.openFolder();
+ *
+ * React Native has no API for any of this, because a phone has no file dialog,
+ * so there is nothing here to be compatible with. The semantics follow
+ * Electron's -- the vocabulary a desktop developer already has -- and the shape
+ * is React Native's.
+ *
+ * ## Why every one of them answers `{canceled, paths}`
+ *
+ * Because "the person pressed Cancel" and "the person chose nothing" are
+ * different answers, and every API that collapses them is one somebody has to
+ * work around. `paths` is a list even for a save and a folder, where it always
+ * has one entry, so that an app moving between the three is not also moving
+ * between result types:
+ *
+ *   const {canceled, paths: [path]} = await dialog.saveFile();
+ *   if (canceled) return;
+ *
+ * ## Why a hook rather than a module
+ *
+ * `useDialog()` returns the same object every time and does not subscribe to
+ * anything, so as a hook it buys exactly one thing: it is the shape the rest of
+ * this package uses, and a component that calls it reads like a component. An
+ * app that wants it outside a component can import `dialog` instead -- it is
+ * the same object, and the hook returns it.
+ *
+ * On a host with no dialog module every call resolves `{canceled: true, paths:
+ * []}` rather than throwing, so the same code runs on a platform that has not
+ * implemented one yet.
+ *
+ * @format
+ */
+/**
+ * A file type a dialog offers to filter by. Extensions are bare -- 'png', not
+ * '.png' and not 'image/png' -- which is what all three desktops translate
+ * from.
+ */
+export type DialogFilter = {
+    name: string;
+    extensions: ReadonlyArray<string>;
+};
+export type DialogOptions = {
+    title?: string;
+    defaultPath?: string;
+    confirmLabel?: string;
+    /** Open only; a save and a folder choose one. */
+    multiple?: boolean;
+    filters?: ReadonlyArray<DialogFilter>;
+};
+/**
+ * Always both, and always a list. "The person pressed Cancel" and "the person
+ * chose nothing" are different answers; `paths` is a list even where it can
+ * only have one entry, so an app moving between the three calls is not also
+ * moving between result types.
+ */
+export type DialogResult = {
+    canceled: boolean;
+    paths: ReadonlyArray<string>;
+};
+export declare const dialog: Readonly<{
+    /**
+     * One or more existing files.
+     *
+     * `{title, defaultPath, confirmLabel, multiple, filters}`, all optional.
+     * `filters` is `[{name, extensions}]` with the extensions bare -- 'png', not
+     * '.png' and not 'image/png' -- which is what all three desktops translate
+     * from.
+     */
+    openFile(options?: DialogOptions | null): Promise<DialogResult>;
+    /**
+     * A path to write to, which may not exist yet. `defaultPath` is the
+     * suggested name, optionally with a directory in front of it.
+     *
+     * Whether an existing file may be overwritten is the platform's question and
+     * it asks for itself; by the time this resolves, the answer was yes.
+     */
+    saveFile(options?: DialogOptions | null): Promise<DialogResult>;
+    /** A directory. `filters` means nothing here and is ignored. */
+    openFolder(options?: DialogOptions | null): Promise<DialogResult>;
+}>;
+export type Dialog = typeof dialog;
+export declare function useDialog(): Dialog;
+//# sourceMappingURL=useDialog.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useDialog.d.ts","sourceRoot":"","sources":["../../src/useDialog.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AAKH;;;;GAIG;AACH,MAAM,MAAM,YAAY,GAAG;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;CACnC,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG;IAC1B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,iDAAiD;IACjD,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,OAAO,CAAC,EAAE,aAAa,CAAC,YAAY,CAAC,CAAC;CACvC,CAAC;AAEF;;;;;GAKG;AACH,MAAM,MAAM,YAAY,GAAG;IACzB,QAAQ,EAAE,OAAO,CAAC;IAClB,KAAK,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;CAC9B,CAAC;AA6BF,eAAO,MAAM,MAAM;IACjB;;;;;;;OAOG;uBACsB,aAAa,GAAG,IAAI,GAAG,OAAO,CAAC,YAAY,CAAC;IAOrE;;;;;;OAMG;uBACsB,aAAa,GAAG,IAAI,GAAG,OAAO,CAAC,YAAY,CAAC;IAOrE,gEAAgE;yBACrC,aAAa,GAAG,IAAI,GAAG,OAAO,CAAC,YAAY,CAAC;EAMvE,CAAC;AAEH,MAAM,MAAM,MAAM,GAAG,OAAO,MAAM,CAAC;AAEnC,wBAAgB,SAAS,IAAI,MAAM,CAIlC"}

package/dist/src/useDialog.js

@@ -0,0 +1,112 @@
+"use strict";
+/**
+ * The native file dialogs.
+ *
+ *   const dialog = useDialog();
+ *
+ *   const {canceled, paths} = await dialog.openFile({
+ *     title: 'Choose an image',
+ *     multiple: true,
+ *     filters: [{name: 'Images', extensions: ['png', 'jpg', 'jpeg']}],
+ *   });
+ *
+ *   const {canceled, paths: [path]} = await dialog.saveFile({
+ *     defaultPath: 'notes.md',
+ *   });
+ *
+ *   const {canceled, paths: [folder]} = await dialog.openFolder();
+ *
+ * React Native has no API for any of this, because a phone has no file dialog,
+ * so there is nothing here to be compatible with. The semantics follow
+ * Electron's -- the vocabulary a desktop developer already has -- and the shape
+ * is React Native's.
+ *
+ * ## Why every one of them answers `{canceled, paths}`
+ *
+ * Because "the person pressed Cancel" and "the person chose nothing" are
+ * different answers, and every API that collapses them is one somebody has to
+ * work around. `paths` is a list even for a save and a folder, where it always
+ * has one entry, so that an app moving between the three is not also moving
+ * between result types:
+ *
+ *   const {canceled, paths: [path]} = await dialog.saveFile();
+ *   if (canceled) return;
+ *
+ * ## Why a hook rather than a module
+ *
+ * `useDialog()` returns the same object every time and does not subscribe to
+ * anything, so as a hook it buys exactly one thing: it is the shape the rest of
+ * this package uses, and a component that calls it reads like a component. An
+ * app that wants it outside a component can import `dialog` instead -- it is
+ * the same object, and the hook returns it.
+ *
+ * On a host with no dialog module every call resolves `{canceled: true, paths:
+ * []}` rather than throwing, so the same code runs on a platform that has not
+ * implemented one yet.
+ *
+ * @format
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dialog = void 0;
+exports.useDialog = useDialog;
+const react_native_1 = require("react-native");
+const NativeDialog = react_native_1.TurboModuleRegistry.get('BasaltDialog');
+const CANCELED = Object.freeze({
+    canceled: true,
+    paths: Object.freeze([]),
+});
+/**
+ * Normalises whatever the native side answered.
+ *
+ * The host is this project's own and answers the right shape, so this is not
+ * defensive about it: what it is for is the host that has no module at all,
+ * where there is no answer to normalise.
+ */
+function answer(result) {
+    if (result == null || !Array.isArray(result.paths)) {
+        return CANCELED;
+    }
+    return { canceled: result.canceled === true, paths: result.paths };
+}
+exports.dialog = Object.freeze({
+    /**
+     * One or more existing files.
+     *
+     * `{title, defaultPath, confirmLabel, multiple, filters}`, all optional.
+     * `filters` is `[{name, extensions}]` with the extensions bare -- 'png', not
+     * '.png' and not 'image/png' -- which is what all three desktops translate
+     * from.
+     */
+    async openFile(options) {
+        if (NativeDialog == null) {
+            return CANCELED;
+        }
+        return answer(await NativeDialog.openFile(options ?? {}));
+    },
+    /**
+     * A path to write to, which may not exist yet. `defaultPath` is the
+     * suggested name, optionally with a directory in front of it.
+     *
+     * Whether an existing file may be overwritten is the platform's question and
+     * it asks for itself; by the time this resolves, the answer was yes.
+     */
+    async saveFile(options) {
+        if (NativeDialog == null) {
+            return CANCELED;
+        }
+        return answer(await NativeDialog.saveFile(options ?? {}));
+    },
+    /** A directory. `filters` means nothing here and is ignored. */
+    async openFolder(options) {
+        if (NativeDialog == null) {
+            return CANCELED;
+        }
+        return answer(await NativeDialog.openFolder(options ?? {}));
+    },
+});
+function useDialog() {
+    // The same object every render. Nothing here depends on a render, so a new
+    // one would only make every effect that lists it a dependency run again.
+    return exports.dialog;
+}
+//# sourceMappingURL=useDialog.js.map

package/dist/src/useDialog.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDialog.js","sourceRoot":"","sources":["../../src/useDialog.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;;;AAuGH,8BAIC;AAxGD,+CAAiD;AAsCjD,MAAM,YAAY,GAAG,kCAAmB,CAAC,GAAG,CAAqB,cAAc,CAAC,CAAC;AAEjF,MAAM,QAAQ,GAAiB,MAAM,CAAC,MAAM,CAAC;IAC3C,QAAQ,EAAE,IAAI;IACd,KAAK,EAAE,MAAM,CAAC,MAAM,CAAC,EAAE,CAA0B;CAClD,CAAC,CAAC;AAEH;;;;;;GAMG;AACH,SAAS,MAAM,CAAC,MAAgD;IAC9D,IAAI,MAAM,IAAI,IAAI,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC;QACnD,OAAO,QAAQ,CAAC;IAClB,CAAC;IACD,OAAO,EAAC,QAAQ,EAAE,MAAM,CAAC,QAAQ,KAAK,IAAI,EAAE,KAAK,EAAE,MAAM,CAAC,KAAK,EAAC,CAAC;AACnE,CAAC;AAEY,QAAA,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;IAClC;;;;;;;OAOG;IACH,KAAK,CAAC,QAAQ,CAAC,OAA8B;QAC3C,IAAI,YAAY,IAAI,IAAI,EAAE,CAAC;YACzB,OAAO,QAAQ,CAAC;QAClB,CAAC;QACD,OAAO,MAAM,CAAC,MAAM,YAAY,CAAC,QAAQ,CAAC,OAAO,IAAI,EAAE,CAAC,CAAC,CAAC;IAC5D,CAAC;IAED;;;;;;OAMG;IACH,KAAK,CAAC,QAAQ,CAAC,OAA8B;QAC3C,IAAI,YAAY,IAAI,IAAI,EAAE,CAAC;YACzB,OAAO,QAAQ,CAAC;QAClB,CAAC;QACD,OAAO,MAAM,CAAC,MAAM,YAAY,CAAC,QAAQ,CAAC,OAAO,IAAI,EAAE,CAAC,CAAC,CAAC;IAC5D,CAAC;IAED,gEAAgE;IAChE,KAAK,CAAC,UAAU,CAAC,OAA8B;QAC7C,IAAI,YAAY,IAAI,IAAI,EAAE,CAAC;YACzB,OAAO,QAAQ,CAAC;QAClB,CAAC;QACD,OAAO,MAAM,CAAC,MAAM,YAAY,CAAC,UAAU,CAAC,OAAO,IAAI,EAAE,CAAC,CAAC,CAAC;IAC9D,CAAC;CACF,CAAC,CAAC;AAIH,SAAgB,SAAS;IACvB,2EAA2E;IAC3E,yEAAyE;IACzE,OAAO,cAAM,CAAC;AAChB,CAAC"}

package/dist/src/useDisplays.d.ts

@@ -0,0 +1,70 @@
+/**
+ * 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
+ */
+/** One display, in the same logical pixels and coordinates windows use. */
+export type Display = {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    /** What is left after the desktop's furniture; equal to the bounds on GTK. */
+    workX: number;
+    workY: number;
+    workWidth: number;
+    workHeight: number;
+    /** Physical pixels per logical pixel. Never zero. */
+    scaleFactor: number;
+    primary: boolean;
+};
+export type PointerPosition = {
+    x: number;
+    y: number;
+    /** False where the desktop will not say -- always, on GTK. */
+    known: boolean;
+};
+/** Whether this platform can be asked at all. */
+export declare const isSupported: boolean;
+/**
+ * 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.
+ */
+export declare function displays(): Display[];
+/** Where the pointer is. A promise: nothing reports the pointer moving. */
+export declare function pointerPosition(): Promise<PointerPosition>;
+/**
+ * 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.
+ */
+export declare function useDisplays(): Display[];
+/** The primary display, or null on a platform with none to report. */
+export declare function primaryDisplay(): Display | null;
+//# sourceMappingURL=useDisplays.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useDisplays.d.ts","sourceRoot":"","sources":["../../src/useDisplays.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAMH,2EAA2E;AAC3E,MAAM,MAAM,OAAO,GAAG;IACpB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,8EAA8E;IAC9E,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,qDAAqD;IACrD,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,OAAO,CAAC;CAClB,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG;IAC5B,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,8DAA8D;IAC9D,KAAK,EAAE,OAAO,CAAC;CAChB,CAAC;AAYF,iDAAiD;AACjD,eAAO,MAAM,WAAW,SAAqC,CAAC;AAE9D;;;;;;;GAOG;AACH,wBAAgB,QAAQ,IAAI,OAAO,EAAE,CAGpC;AAED,2EAA2E;AAC3E,wBAAgB,eAAe,IAAI,OAAO,CAAC,eAAe,CAAC,CAK1D;AAED;;;;;;GAMG;AACH,wBAAgB,WAAW,IAAI,OAAO,EAAE,CAkBvC;AAED,sEAAsE;AACtE,wBAAgB,cAAc,IAAI,OAAO,GAAG,IAAI,CAG/C"}