@opengeni/react 0.13.0 → 0.20.0

package/dist/machines.d.ts

@@ -1,4 +1,413 @@
-export { a as CONNECTION_STATUS_META, b as ConnectionDot, c as ConnectionDotProps, d as ConnectionStatus, e as ConnectionStatusMeta, f as ConnectionStatusPill, g as ConnectionStatusPillProps, D as DeviceFlowPhase, E as EnrollmentConsent, h as EnrollmentConsentMachine, i as EnrollmentConsentPhase, j as EnrollmentConsentProps, k as EnrollmentDeviceFlow, l as EnrollmentDeviceFlowProps, M as MACHINE_STATE_BADGE_META, m as MachineCard, n as MachineCardProps, o as MachineDockBar, p as MachineDockBarProps, q as MachineMetrics, r as MachineMetricsProps, s as MachineStateBadgeMeta, t as MachineStatusPill, u as MachineStatusPillProps, v as MachinesClientLike, w as MachinesDashboard, x as MachinesDashboardProps, A as SharedMachineDisclosure, B as SharedMachineDisclosureProps, U as UseMachinesOptions, F as UseMachinesResult, G as connectionStatusForState, H as useMachines } from './machines-CnlMb7E-.js';
+import { MachineState, MetricSample, MachineView, MachineKind, MachinesResponse } from '@opengeni/sdk';
 export { MachineKind, MachineMetricsSeriesResponse, MachineState, MachineView, MachinesResponse, MetricSample } from '@opengeni/sdk';
-import 'react/jsx-runtime';
-import 'react';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { C as ClientOverride } from './session-context-DIFFlXKc.js';
+
+/**
+ * The three connection-status pill values the UI surfaces across the dashboard,
+ * the dock, and the timeline. `consent_required` / `display_unavailable` /
+ * `enrolling` are NOT connection states — they map onto a connection state for
+ * the pill and carry their own badge separately.
+ */
+type ConnectionStatus = "online" | "reconnecting" | "offline";
+/** Project a machine `state` onto its connection-status pill value. */
+declare function connectionStatusForState(state: MachineState): ConnectionStatus;
+
+type ConnectionStatusMeta = {
+    label: string;
+    dotClassName: string;
+    badgeClassName: string;
+    /** Live/transient states breathe; settled states hold still. */
+    pulse: boolean;
+};
+/** Token-backed meta for the three connection-status pill values. */
+declare const CONNECTION_STATUS_META: Record<ConnectionStatus, ConnectionStatusMeta>;
+type MachineStateBadgeMeta = {
+    label: string;
+    badgeClassName: string;
+};
+/**
+ * The non-connection state badges that ride ALONGSIDE the connection pill —
+ * `consent_required` / `display_unavailable` / `enrolling` describe a capability
+ * limitation, not reachability, so they render as their own tinted chip.
+ */
+declare const MACHINE_STATE_BADGE_META: Partial<Record<MachineState, MachineStateBadgeMeta>>;
+type ConnectionStatusPillProps = {
+    status: ConnectionStatus;
+    /** Override the label ("Online" -> "Connected", ...). */
+    label?: string | undefined;
+    size?: "sm" | "md" | undefined;
+    className?: string | undefined;
+};
+/**
+ * The connection-status pill (online / reconnecting / offline) surfaced across
+ * the Machines dashboard, the dock header, and the session timeline. Reconnecting
+ * breathes (the resiliency-as-headline blip), online/offline hold still.
+ */
+declare function ConnectionStatusPill({ status, label, size, className, }: ConnectionStatusPillProps): react_jsx_runtime.JSX.Element;
+type ConnectionDotProps = {
+    status: ConnectionStatus;
+    className?: string | undefined;
+};
+/** Just the dot — for dense rows, the dock header, and timeline notices. */
+declare function ConnectionDot({ status, className }: ConnectionDotProps): react_jsx_runtime.JSX.Element;
+type MachineStatusPillProps = {
+    /** The machine's full state — drives the connection pill + any state badge. */
+    state: MachineState;
+    /** How many live sessions share this lease (renders a "Shared" chip when >1). */
+    sharedSessionCount?: number | undefined;
+    size?: "sm" | "md" | undefined;
+    className?: string | undefined;
+};
+/**
+ * The composite machine status surface: the connection pill PLUS any
+ * consent/display/enrolling badge PLUS a shared-in-use chip. One component the
+ * dashboard row, the dock header, and the timeline all reuse so the status
+ * language is identical everywhere.
+ */
+declare function MachineStatusPill({ state, sharedSessionCount, size, className, }: MachineStatusPillProps): react_jsx_runtime.JSX.Element;
+
+type MachineMetricsProps = {
+    /** The latest metric sample, or null when the machine hasn't reported yet. */
+    metrics: MetricSample | null;
+    /** Compact (dashboard row) vs full (the dock detail). */
+    density?: "compact" | "full" | undefined;
+    className?: string | undefined;
+};
+/**
+ * Per-machine resource meters: CPU%, load average, memory, disk, and GPU when
+ * present. Renders the M2 `machine_metrics_latest` sample. When `metrics` is
+ * null the panel shows a quiet "no samples yet" placeholder (offline / just
+ * enrolled). GPU rows only render when `gpuUtilPct` is non-null.
+ */
+declare function MachineMetrics({ metrics, density, className }: MachineMetricsProps): react_jsx_runtime.JSX.Element;
+
+type MachineCardProps = {
+    machine: MachineView;
+    /** Attach/swap the session's active sandbox to this machine. */
+    onAttach?: ((machine: MachineView) => void) | undefined;
+    /** Whether an attach/swap is currently in flight (disables the affordance). */
+    attaching?: boolean | undefined;
+    /** Short recent history (e.g. 15m) — drives the card's CPU trend + preview. */
+    series?: MetricSample[] | undefined;
+    /** Open the full per-machine telemetry detail. Makes the whole card actionable. */
+    onOpenDetail?: ((machine: MachineView) => void) | undefined;
+    now?: number | undefined;
+    className?: string | undefined;
+};
+/**
+ * One machine in the Machines dashboard: name + kind + OS/arch, the fused HEALTH
+ * verdict, latest resource meters, a CPU trend that previews the history, live
+ * freshness, and attach/swap. The whole card opens the telemetry detail when
+ * `onOpenDetail` is wired. The session's active sandbox carries an accent edge.
+ */
+declare function MachineCard({ machine, onAttach, attaching, series, onOpenDetail, now, className, }: MachineCardProps): react_jsx_runtime.JSX.Element;
+
+type MachineHealthPillProps = {
+    state: MachineState;
+    metrics: MetricSample | null;
+    now?: number | undefined;
+    size?: "sm" | "md" | undefined;
+    className?: string | undefined;
+};
+declare function MachineHealthPill({ state, metrics, now, size, className, }: MachineHealthPillProps): react_jsx_runtime.JSX.Element;
+
+type HealthLevel = "healthy" | "degraded" | "critical" | "offline" | "unknown";
+type HealthVerdict = {
+    level: HealthLevel;
+    /** Title-case label for the pill ("Healthy", "Under load", "Critical", …). */
+    label: string;
+    /** One short human clause naming the dominant cause ("Memory 94%", "No display"…). */
+    reason: string;
+    /** The latest sample is older than we'd expect from a live agent (~5s cadence). */
+    stale: boolean;
+};
+/** Fold a machine's reachability + latest sample + wall-clock into one verdict. */
+declare function deriveHealth(state: MachineState, metrics: MetricSample | null, now?: number): HealthVerdict;
+/**
+ * The token color ramp for a health level. Green/amber/red/grey is the
+ * universally-legible traffic model; we reserve it for the HEALTH verdict
+ * specifically (per-resource meters keep their own ramp in `machine-metrics`).
+ */
+declare const HEALTH_TOKEN: Record<HealthLevel, {
+    text: string;
+    dot: string;
+    soft: string;
+}>;
+/** Live/transient levels breathe; settled levels hold still. */
+declare function healthPulses(level: HealthLevel): boolean;
+
+type SeriesPoint = {
+    t: number;
+    v: number | null;
+};
+type MetricHistoryChartProps = {
+    points: SeriesPoint[];
+    /** Fixed ceiling (100 for %) or "auto" to fit the data with headroom. */
+    yMax?: number | "auto";
+    yMin?: number;
+    /** Format a value for the axis + readout (default: rounded + unit). */
+    format?: (v: number) => string;
+    unit?: string;
+    /** Stroke/fill hue — any CSS color; pass a token var to stay theme-safe. */
+    color?: string;
+    thresholds?: {
+        warn?: number | undefined;
+        crit?: number | undefined;
+    } | undefined;
+    height?: number;
+    /** Human range label for the empty state ("in the last hour"). */
+    rangeLabel?: string | undefined;
+    className?: string | undefined;
+};
+declare function MetricHistoryChart({ points, yMax, yMin, format, unit, color, thresholds, height, rangeLabel, className, }: MetricHistoryChartProps): react_jsx_runtime.JSX.Element;
+
+type MetricSparklineProps = {
+    points: SeriesPoint[];
+    color?: string;
+    yMax?: number | "auto";
+    height?: number;
+    className?: string | undefined;
+};
+declare function MetricSparkline({ points, color, yMax, height, className, }: MetricSparklineProps): react_jsx_runtime.JSX.Element;
+
+type MetricWindow = "15m" | "1h" | "6h" | "24h";
+declare const METRIC_WINDOWS: MetricWindow[];
+declare const WINDOW_LABEL: Record<MetricWindow, string>;
+type MetricKey = "cpu" | "mem" | "disk" | "load" | "gpu";
+type MetricDef = {
+    key: MetricKey;
+    title: string;
+    unit: string;
+    yMax: number | "auto";
+    color: string;
+    thresholds?: {
+        warn?: number;
+        crit?: number;
+    };
+    pick: (s: MetricSample) => number | null;
+    /** Big current-value string for tiles/badges. */
+    current: (s: MetricSample) => string;
+    /** Optional sub-line under the current value. */
+    sub?: (s: MetricSample) => string | null;
+};
+declare const METRICS: MetricDef[];
+declare function pointsFor(def: MetricDef, samples: MetricSample[]): SeriesPoint[];
+
+type MachineDetailProps = {
+    machine: MachineView;
+    /** Downsampled history for the active window (from `fetchSeries`). */
+    series: MetricSample[];
+    window: MetricWindow;
+    onWindowChange: (w: MetricWindow) => void;
+    loadingSeries?: boolean | undefined;
+    onBack?: (() => void) | undefined;
+    now?: number | undefined;
+    className?: string | undefined;
+};
+declare function MachineDetail({ machine, series, window, onWindowChange, loadingSeries, onBack, now, className, }: MachineDetailProps): react_jsx_runtime.JSX.Element;
+
+type MachinesDashboardProps = {
+    machines: MachineView[];
+    /** The session's active sandbox id (drives the per-card "Active" marker). */
+    activeSandboxId?: string | null | undefined;
+    loading?: boolean | undefined;
+    error?: Error | null | undefined;
+    /** Attach/swap the session's active sandbox to a machine. */
+    onAttach?: ((machine: MachineView) => void) | undefined;
+    /** The sandbox id currently being attached/swapped to (disables that card). */
+    attachingSandboxId?: string | null | undefined;
+    /** Short recent history per machine (keyed by sandboxId) — drives card sparklines. */
+    seriesByMachine?: Record<string, MetricSample[]> | undefined;
+    /** Open the per-machine telemetry detail (makes each card actionable). */
+    onOpenDetail?: ((machine: MachineView) => void) | undefined;
+    /** Shared clock so freshness/relative times render consistently across cards. */
+    now?: number | undefined;
+    /** Open the enrollment flow (the "Enroll a machine" CTA). */
+    onEnroll?: (() => void) | undefined;
+    onRefresh?: (() => void) | undefined;
+    className?: string | undefined;
+};
+/**
+ * The workspace Machines dashboard: the fleet of selfhosted enrollments + the
+ * session's managed sandbox, each with its connection-status pill, state badges,
+ * latest metrics, and an attach/swap affordance. Renders the empty state (no
+ * machines → enroll CTA), a load error, and the populated grid. The component
+ * is purely presentational — feed it `MachinesResponse` data via `useMachines`.
+ */
+declare function MachinesDashboard({ machines, activeSandboxId, loading, error, onAttach, attachingSandboxId, seriesByMachine, onOpenDetail, now, onEnroll, onRefresh, className, }: MachinesDashboardProps): react_jsx_runtime.JSX.Element;
+
+type MachineDockBarProps = {
+    /** The active machine's display name. */
+    name: string;
+    kind: MachineKind;
+    state: MachineState;
+    /** Live sessions sharing this whole-machine lease (>1 ⇒ shared disclosure). */
+    sharedSessionCount?: number | undefined;
+    className?: string | undefined;
+};
+/**
+ * A slim bar that surfaces WHICH machine the dock surfaces (Files/Terminal/
+ * Desktop) are bound to + its connection status. Mounted above the dock tabs so
+ * the user always knows whether they are looking at the Modal box or their own
+ * machine, and whether it is online / reconnecting / offline. The surfaces below
+ * render IDENTICALLY regardless of backend — this bar is the only backend-aware
+ * chrome (the dock-parity contract: selfhosted == Modal for the surfaces).
+ */
+declare function MachineDockBar({ name, kind, state, className }: MachineDockBarProps): react_jsx_runtime.JSX.Element;
+type SharedMachineDisclosureProps = {
+    sharedSessionCount: number;
+    /** Compact (inline strip) vs full (a notice block). */
+    density?: "compact" | "full" | undefined;
+    className?: string | undefined;
+};
+/**
+ * The "shared — another session is on this machine" disclosure. Surfaced in the
+ * dock (and reused on the desktop take-control gate) so the user knows others are
+ * driving the same whole-machine lease. Render when `sharedSessionCount > 1`.
+ */
+declare function SharedMachineDisclosure({ sharedSessionCount, density, className, }: SharedMachineDisclosureProps): react_jsx_runtime.JSX.Element;
+
+/** The poll state of an in-flight device-flow enrollment. */
+type DeviceFlowPhase = "pending" | "authorized" | "denied" | "expired" | "disabled";
+type EnrollmentDeviceFlowProps = {
+    /** The short user code the agent printed (shown big for the human to confirm). */
+    userCode: string;
+    /** Where the user approves — the same-origin device page. */
+    verificationUri: string;
+    /** The complete URI (code pre-filled) for a one-click / QR open. */
+    verificationUriComplete?: string | undefined;
+    /** The install one-liner the user ran (echoed for context). Optional. */
+    installCommand?: string | undefined;
+    phase?: DeviceFlowPhase | undefined;
+    /** Seconds remaining before the code expires (drives a quiet countdown). */
+    expiresInSeconds?: number | undefined;
+    onCopyCode?: (() => void) | undefined;
+    onCopyInstall?: (() => void) | undefined;
+    onOpenVerification?: (() => void) | undefined;
+    className?: string | undefined;
+};
+/**
+ * The IN-SESSION device-flow panel: the agent (after the install one-liner) prints
+ * a short `userCode` + a `verificationUri`; this surfaces them so the user can open
+ * the approve page and confirm the code. Polls in the caller; this renders the
+ * pending → authorized/denied/expired progression with a connection pill. This is
+ * the FIRST step of the IA flow (device-flow → Machines list → attach/swap).
+ */
+declare function EnrollmentDeviceFlow({ userCode, verificationUri, verificationUriComplete, installCommand, phase, expiresInSeconds, onCopyCode, onCopyInstall, onOpenVerification, className, }: EnrollmentDeviceFlowProps): react_jsx_runtime.JSX.Element;
+
+/** The machine identity surfaced to the approver, from the device-flow start. */
+type EnrollmentConsentMachine = {
+    /** Human-friendly name (hostname by default). */
+    machineName: string;
+    os: string;
+    arch: string;
+    /** The agent can offer a display (a real screen / Xvfb is available). */
+    canOfferDisplay: boolean;
+    /** The agent requests screen control (computer-use). */
+    requestsScreenControl: boolean;
+};
+/** The phase of the approve page (drives the rendered panel). */
+type EnrollmentConsentPhase = "review" | "approving" | "approved" | "denied" | "error";
+type EnrollmentConsentProps = {
+    /** The short code the user typed / scanned (echoed back for confirmation). */
+    userCode: string;
+    machine: EnrollmentConsentMachine;
+    phase?: EnrollmentConsentPhase | undefined;
+    /** Approve with the chosen screen-control consent. */
+    onApprove?: ((allowScreenControl: boolean) => void) | undefined;
+    onDeny?: (() => void) | undefined;
+    /** Error message when phase === "error". */
+    errorMessage?: string | undefined;
+    className?: string | undefined;
+};
+/**
+ * The user-facing APPROVE page for the device-flow enrollment: a LOUD,
+ * un-minimised whole-machine consent. Approving grants the agent FULL access to
+ * this machine — exec, files, terminal — and (when toggled) live screen control.
+ * The danger framing is deliberate (§18 hardening: whole-machine = loud consent),
+ * never buried. Renders review / approving / approved / denied / error phases.
+ */
+declare function EnrollmentConsent({ userCode, machine, phase, onApprove, onDeny, errorMessage, className, }: EnrollmentConsentProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * The slice of the SDK client the Machines surface needs. The method NAMES +
+ * SIGNATURES match M10's `OpenGeniClient` (`listMachines`, `machineMetricsSeries`)
+ * so the real SDK client satisfies this surface DIRECTLY for the read paths — no
+ * adapter needed. It is declared structurally (not a hard `OpenGeniClient` Pick)
+ * so a test/demo/Geni-frontend client can stand in, keeping the hook dual-consumer
+ * safe (works in apps/web AND the separate Geni frontend).
+ *
+ * The active-sandbox SWAP is now a typed SDK call (`swapActiveSandbox`, the M7
+ * user-authenticated REST equivalent of the `sandbox_swap` MCP tool). The real
+ * SDK client satisfies it structurally, so the default attach path is wired
+ * WHENEVER a sessionId is in scope (the swap is session-scoped). `attachMachine`
+ * stays an OPTIONAL escape hatch for a host that wants to supply its own swap
+ * adapter; when neither it nor a sessionId is present, attach is a no-op and the
+ * card hides the button.
+ */
+type MachinesClientLike = {
+    /** GET /v1/workspaces/:ws/machines — the dashboard list + active pointer. */
+    listMachines: (workspaceId: string, options?: {
+        sessionId?: string;
+        signal?: AbortSignal;
+    }) => Promise<MachinesResponse>;
+    /** GET .../machines/:enrollmentId/metrics/series — the downsampled history. */
+    machineMetricsSeries?: (workspaceId: string, enrollmentId: string, options?: {
+        window?: "15m" | "1h" | "6h" | "24h";
+    }) => Promise<MetricSample[]>;
+    /**
+     * POST .../sessions/:sessionId/active-sandbox — swap the session's active
+     * sandbox to a machine. The default swap path; the real SDK client provides it.
+     */
+    swapActiveSandbox?: (workspaceId: string, sessionId: string, request: {
+        target: string;
+    }) => Promise<unknown>;
+    /**
+     * Host-supplied swap adapter (an escape hatch). When present it wins over the
+     * default `swapActiveSandbox` path. Session-scoped, like the swap it backs.
+     */
+    attachMachine?: (workspaceId: string, sessionId: string, sandboxId: string) => Promise<unknown>;
+};
+type UseMachinesOptions = ClientOverride & {
+    pollIntervalMs?: number | undefined;
+    enabled?: boolean | undefined;
+    /** Scope the list to a session (adds the synthetic Modal group box + pointer). */
+    sessionId?: string | undefined;
+    /**
+     * Override the client with one implementing `MachinesClientLike`. Defaults to
+     * the provider client cast to the surface (the real SDK client satisfies the
+     * read paths). An app supplies an adapter to wire `attachMachine` (the swap).
+     */
+    machinesClient?: MachinesClientLike | undefined;
+};
+type UseMachinesResult = {
+    machines: MachineView[];
+    activeSandboxId: string | null;
+    activeEpoch: number;
+    loading: boolean;
+    error: Error | null;
+    refresh: () => Promise<void>;
+    /** Attach/swap the session's active sandbox to a machine (returns the new pointer). */
+    attach: (sandboxId: string) => Promise<boolean>;
+    /** Whether the host wired an attach/swap path (drives the card affordance). */
+    canAttach: boolean;
+    /** Fetch a downsampled metric series for one enrolled machine. */
+    fetchSeries: (enrollmentId: string, window?: "15m" | "1h" | "6h" | "24h") => Promise<MetricSample[]>;
+    attaching: boolean;
+    /** The sandbox id of the in-flight attach (for per-card spinner gating). */
+    attachingSandboxId: string | null;
+    mutationError: Error | null;
+    clearMutationError: () => void;
+};
+/**
+ * The workspace Machines fleet: the selfhosted enrollments + the session's Modal
+ * box, each with latest metrics + state, plus the active-sandbox pointer. Polls
+ * the M10 `GET /machines` endpoint and exposes attach/swap + a metric-series
+ * fetch. Renders via `<MachinesDashboard>`. Dual-consumer safe: it reads only the
+ * structural `MachinesClientLike` surface, so it works in apps/web AND the Geni
+ * frontend (each provides its own client/adapter).
+ */
+declare function useMachines(options?: UseMachinesOptions): UseMachinesResult;
+
+export { CONNECTION_STATUS_META, ConnectionDot, type ConnectionDotProps, type ConnectionStatus, type ConnectionStatusMeta, ConnectionStatusPill, type ConnectionStatusPillProps, type DeviceFlowPhase, EnrollmentConsent, type EnrollmentConsentMachine, type EnrollmentConsentPhase, type EnrollmentConsentProps, EnrollmentDeviceFlow, type EnrollmentDeviceFlowProps, HEALTH_TOKEN, type HealthLevel, type HealthVerdict, MACHINE_STATE_BADGE_META, METRICS, METRIC_WINDOWS, MachineCard, type MachineCardProps, MachineDetail, type MachineDetailProps, MachineDockBar, type MachineDockBarProps, MachineHealthPill, type MachineHealthPillProps, MachineMetrics, type MachineMetricsProps, type MachineStateBadgeMeta, MachineStatusPill, type MachineStatusPillProps, type MachinesClientLike, MachinesDashboard, type MachinesDashboardProps, type MetricDef, MetricHistoryChart, type MetricHistoryChartProps, type MetricKey, MetricSparkline, type MetricSparklineProps, type MetricWindow, type SeriesPoint, SharedMachineDisclosure, type SharedMachineDisclosureProps, type UseMachinesOptions, type UseMachinesResult, WINDOW_LABEL, connectionStatusForState, deriveHealth, healthPulses, pointsFor, useMachines };

package/dist/machines.js

@@ -4,30 +4,54 @@ import {
   ConnectionStatusPill,
   EnrollmentConsent,
   EnrollmentDeviceFlow,
+  HEALTH_TOKEN,
   MACHINE_STATE_BADGE_META,
+  METRICS,
+  METRIC_WINDOWS,
   MachineCard,
+  MachineDetail,
   MachineDockBar,
+  MachineHealthPill,
   MachineMetrics,
   MachineStatusPill,
   MachinesDashboard,
+  MetricHistoryChart,
+  MetricSparkline,
   SharedMachineDisclosure,
+  WINDOW_LABEL,
   connectionStatusForState,
+  deriveHealth,
+  healthPulses,
+  pointsFor,
   useMachines
-} from "./chunk-NFYVQWIB.js";
+} from "./chunk-6BXBGJ3B.js";
+import "./chunk-TK7G6XLT.js";
+import "./chunk-HHFA4AFX.js";
 export {
   CONNECTION_STATUS_META,
   ConnectionDot,
   ConnectionStatusPill,
   EnrollmentConsent,
   EnrollmentDeviceFlow,
+  HEALTH_TOKEN,
   MACHINE_STATE_BADGE_META,
+  METRICS,
+  METRIC_WINDOWS,
   MachineCard,
+  MachineDetail,
   MachineDockBar,
+  MachineHealthPill,
   MachineMetrics,
   MachineStatusPill,
   MachinesDashboard,
+  MetricHistoryChart,
+  MetricSparkline,
   SharedMachineDisclosure,
+  WINDOW_LABEL,
   connectionStatusForState,
+  deriveHealth,
+  healthPulses,
+  pointsFor,
   useMachines
 };
 //# sourceMappingURL=machines.js.map

package/dist/noto-sans-arabic-loader-IA2T4X2A.js

@@ -0,0 +1,21 @@
+// src/lib/noto-sans-arabic-loader.ts
+import fontUrl from "@fontsource-variable/noto-sans-arabic/files/noto-sans-arabic-arabic-wght-normal.woff2";
+import unicodeRanges from "@fontsource-variable/noto-sans-arabic/unicode.json";
+var loading;
+function loadNotoSansArabic() {
+  loading ??= new FontFace(
+    "Noto Sans Arabic Variable",
+    `url("${fontUrl}") format("woff2-variations")`,
+    { style: "normal", weight: "100 900", unicodeRange: unicodeRanges.arabic }
+  ).load().then((font) => {
+    document.fonts.add(font);
+  }).catch((error) => {
+    loading = void 0;
+    throw error;
+  });
+  return loading;
+}
+export {
+  loadNotoSansArabic
+};
+//# sourceMappingURL=noto-sans-arabic-loader-IA2T4X2A.js.map

package/dist/noto-sans-arabic-loader-IA2T4X2A.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/lib/noto-sans-arabic-loader.ts"],"sourcesContent":["import fontUrl from \"@fontsource-variable/noto-sans-arabic/files/noto-sans-arabic-arabic-wght-normal.woff2\";\nimport unicodeRanges from \"@fontsource-variable/noto-sans-arabic/unicode.json\";\n\nlet loading: Promise<void> | undefined;\n\nexport function loadNotoSansArabic(): Promise<void> {\n  loading ??= new FontFace(\n    \"Noto Sans Arabic Variable\",\n    `url(\"${fontUrl}\") format(\"woff2-variations\")`,\n    { style: \"normal\", weight: \"100 900\", unicodeRange: unicodeRanges.arabic },\n  )\n    .load()\n    .then((font) => {\n      document.fonts.add(font);\n    })\n    .catch((error: unknown) => {\n      loading = undefined;\n      throw error;\n    });\n  return loading;\n}\n"],"mappings":";AAAA,OAAO,aAAa;AACpB,OAAO,mBAAmB;AAE1B,IAAI;AAEG,SAAS,qBAAoC;AAClD,cAAY,IAAI;AAAA,IACd;AAAA,IACA,QAAQ,OAAO;AAAA,IACf,EAAE,OAAO,UAAU,QAAQ,WAAW,cAAc,cAAc,OAAO;AAAA,EAC3E,EACG,KAAK,EACL,KAAK,CAAC,SAAS;AACd,aAAS,MAAM,IAAI,IAAI;AAAA,EACzB,CAAC,EACA,MAAM,CAAC,UAAmB;AACzB,cAAU;AACV,UAAM;AAAA,EACR,CAAC;AACH,SAAO;AACT;","names":[]}