@nativedesktop/react 0.1.0

package/dist/jsx-dev-runtime.js

@@ -0,0 +1,6 @@
+// src/jsx-dev-runtime.ts
+import { jsxDEV, Fragment } from "react/jsx-dev-runtime";
+export {
+  jsxDEV,
+  Fragment
+};

package/dist/jsx-runtime.js

@@ -0,0 +1,20 @@
+// src/generated/intrinsics.ts
+import { jsx, jsxs, Fragment } from "react/jsx-runtime";
+var styleKeySpec = {
+  background: null,
+  color: null,
+  font: ["fontSize", "fontWeight", "fontFamily"],
+  padding: null,
+  margin: null,
+  hexpand: null,
+  vexpand: null,
+  halign: null,
+  valign: null,
+  border: ["borderWidth", "borderColor", "borderRadius"]
+};
+var cssClassSpec = ["suggested-action", "destructive-action", "flat", "raised", "circular", "pill", "linked", "toolbar", "spacer", "title-1", "title-2", "title-3", "title-4", "heading", "document", "body", "caption-heading", "caption", "monospace", "numeric", "accent", "success", "warning", "error", "boxed-list", "boxed-list-separate", "card", "activatable", "navigation-sidebar", "nd-native-sidebar", "selection-mode", "osd", "dimmed", "background", "view", "frame", "compact", "menu", "inline", "large-title", "property", "round", "opaque", "devel", "icon-dropshadow", "lowres-icon"];
+export {
+  jsxs,
+  jsx,
+  Fragment
+};

package/dist/packages/react/src/css-classes-validate.d.ts

@@ -0,0 +1,3 @@
+export declare class CssClassError extends Error {
+}
+export declare function validateCssClasses(classes: unknown): void;

package/dist/packages/react/src/dev-react.d.ts

@@ -0,0 +1,23 @@
+import * as ReactFirstEval from "react";
+declare global {
+    var __nd_react: typeof ReactFirstEval | undefined;
+}
+export declare const useState: typeof ReactFirstEval.useState;
+export declare const useEffect: typeof ReactFirstEval.useEffect;
+export declare const useLayoutEffect: typeof ReactFirstEval.useLayoutEffect;
+export declare const useMemo: typeof ReactFirstEval.useMemo;
+export declare const useCallback: typeof ReactFirstEval.useCallback;
+export declare const useRef: typeof ReactFirstEval.useRef;
+export declare const useContext: typeof ReactFirstEval.useContext;
+export declare const useReducer: typeof ReactFirstEval.useReducer;
+export declare const useTransition: typeof ReactFirstEval.useTransition;
+export declare const useDeferredValue: typeof ReactFirstEval.useDeferredValue;
+export declare const useSyncExternalStore: typeof ReactFirstEval.useSyncExternalStore;
+export declare const useId: typeof ReactFirstEval.useId;
+export declare const use: typeof ReactFirstEval.use;
+export declare const startTransition: typeof ReactFirstEval.startTransition;
+export declare const memo: typeof ReactFirstEval.memo;
+export declare const forwardRef: typeof ReactFirstEval.forwardRef;
+export declare const createContext: typeof ReactFirstEval.createContext;
+export declare const Suspense: typeof ReactFirstEval.Suspense;
+export declare const Fragment: typeof ReactFirstEval.Fragment;

package/dist/packages/react/src/dialogs.d.ts

@@ -0,0 +1,54 @@
+import type { NdNodeRef } from "./generated/intrinsics.ts";
+import type { FileFilter } from "./system.ts";
+export type { FileFilter };
+export interface DialogButton {
+    id: string;
+    label: string;
+    style?: "default" | "suggested" | "destructive";
+}
+export interface ShowAlertOptions {
+    title: string;
+    body?: string;
+    buttons: DialogButton[];
+}
+export interface AlertResult {
+    buttonId: string;
+}
+export interface OpenFileOptions {
+    multiple?: boolean;
+    directories?: boolean;
+    filters?: FileFilter[];
+}
+export interface OpenFileResult {
+    canceled: boolean;
+    paths: string[];
+}
+export interface SaveFileOptions {
+    suggestedName?: string;
+    defaultDir?: string;
+    filters?: FileFilter[];
+}
+export interface SaveFileResult {
+    canceled: boolean;
+    path: string | null;
+}
+export interface ShowAboutOptions {
+    appName: string;
+    version: string;
+    developer?: string;
+    website?: string;
+}
+export declare function showAlert(node: NdNodeRef<"window">, options: ShowAlertOptions): Promise<AlertResult>;
+export declare function openFile(node: NdNodeRef<"window">, options?: OpenFileOptions): Promise<OpenFileResult>;
+export declare function saveFile(node: NdNodeRef<"window">, options?: SaveFileOptions): Promise<SaveFileResult>;
+export declare function showAbout(node: NdNodeRef<"window">, options: ShowAboutOptions): void;
+export declare function showTabOverview(node: NdNodeRef<"window">): void;
+export declare function onAlertResult(node: NdNodeRef<"window">, e: {
+    data: unknown;
+}): void;
+export declare function onOpenFileResult(node: NdNodeRef<"window">, e: {
+    data: unknown;
+}): void;
+export declare function onSaveFileResult(node: NdNodeRef<"window">, e: {
+    data: unknown;
+}): void;

package/dist/packages/react/src/errors.d.ts

@@ -0,0 +1,55 @@
+export type NdErrorKind = "unhandledRejection" | "uncaughtException" | "renderUncaught" | "renderCaught" | "renderRecoverable";
+export interface NdErrorContext {
+    kind: NdErrorKind;
+    /** True when the process will exit after handlers run. */
+    fatal: boolean;
+    /** Original thrown/rejected value, verbatim (may not be an Error). */
+    raw: unknown;
+    /** React component stack; present only for the three render-phase kinds. */
+    componentStack?: string;
+}
+export type NdErrorHandler = (error: Error, context: NdErrorContext) => void;
+export interface UnhandledErrorPolicy {
+    unhandledRejection?: "report" | "fatal";
+    uncaughtException?: "report" | "fatal";
+    /** false suppresses the framework's own stderr line (app ships its own
+     *  logger). Subscribers still fire. Default true. */
+    log?: boolean;
+}
+interface ErrorsState {
+    policy: UnhandledErrorPolicy;
+    handlers: Set<NdErrorHandler>;
+    /** Timestamps of admitted non-fatal reports inside the rolling window. */
+    stamps: number[];
+    suppressedLogged: boolean;
+    hintShown: boolean;
+    /** Errors already reported as renderUncaught: the follow-on
+     *  uncaughtException (React rethrows the callback's throw in a setTimeout)
+     *  must exit without a duplicate report. */
+    renderFatal: WeakSet<object>;
+}
+declare global {
+    var __nd_errors: ErrorsState | undefined;
+    var __nd_errors_installed: boolean | undefined;
+}
+/** Pure resolver, exported for tests. Precedence: explicit policy >
+ *  ND_FATAL_REJECTIONS=1 env > built-in defaults. */
+export declare function decide(kind: NdErrorKind, p: UnhandledErrorPolicy): "report" | "fatal";
+/** Subscribe to every reported error. Returns an unsubscribe fn. Handlers
+ *  run in registration order; a handler that itself throws is caught and
+ *  logged, never escalated. Same HMR caveat as system.ts's app.on*: a
+ *  module-top-level call re-subscribes a fresh closure each hot re-eval, so
+ *  register from useMountEffect or a module that runs once. */
+export declare function onUnhandledError(handler: NdErrorHandler): () => void;
+/** App-entry policy override. Merges over the current policy. */
+export declare function setUnhandledErrorPolicy(p: UnhandledErrorPolicy): void;
+/** True when a non-fatal report still fits the rolling window; exported for
+ *  tests only. Logs the suppression notice once per exhaustion. */
+export declare function admitReport(): boolean;
+/** Called by renderer.ts's createContainer callbacks. Not public API. */
+export declare function reportRenderError(raw: unknown, kind: "renderUncaught" | "renderCaught" | "renderRecoverable", componentStack?: string): void;
+/** Installs the process-level handlers once per process; render() calls this
+ *  before Ndp.connect() (the wire send no-ops until connected). Guarded on a
+ *  globalThis flag so a `bun --hot` re-eval never accumulates listeners. */
+export declare function installErrorHandlers(): void;
+export {};