@faclon-labs/app-sdk 0.1.0

package/README.md

@@ -0,0 +1,54 @@
+# @faclon-labs/app-sdk
+
+IOSense sign-in and plant data for React apps.
+
+```bash
+npm install @faclon-labs/app-sdk
+```
+
+## Sign-in
+
+Wrap the app in `<IOSenseApp>`. It takes the session IOSense hands over — the launchpad's SSO
+token (`?token=`, exchanged once), a bearer on the URL, or the `.iosense.io` cookie — takes the token
+out of the address, and keeps it in this browser. With no session it shows a sign-in screen.
+
+```tsx
+import { IOSenseApp } from '@faclon-labs/app-sdk';
+
+createRoot(document.getElementById('root')!).render(
+  <IOSenseApp name="Kiln monitor">
+    <App />
+  </IOSenseApp>,
+);
+```
+
+| `auth` | With no session |
+|---|---|
+| `"required"` (default) | the sign-in screen |
+| `"optional"` | the app opens; plant data is sample data |
+| `"none"` | no IOSense sign-in at all |
+
+`useIOSense()` gives `{ token, apiBaseUrl, sample, signOut }`. Another region or stack:
+`<IOSenseApp apiBaseUrl="https://appserver.us.iosense.io">` or `configure({ apiBaseUrl })`.
+
+## Plant data (UNS)
+
+Topics are `uns:<workspace>://<path>:<aggregation>`, the same strings io-lens dashboards use.
+`uns:design://…` topics, and every topic while `sample` is true, return steady sample values.
+
+```tsx
+const { data } = useLatest(['uns:ws_1://plant/kiln/feed:last']);            // polls every 60 s
+const { data: trend } = useSeries(['uns:ws_1://plant/kiln/power:average'], { hours: 24, bucket: 'hour' });
+```
+
+## The viewer and IOSense's APIs
+
+```tsx
+const { user } = useUser(); // { id, email, name, organisation }
+const devices = await request(`${apiBaseUrl}/api/account/devices`, { auth: 'iosense' });
+const { data, loading, error } = useRequest(url, { auth: 'iosense' });
+```
+
+`auth: 'iosense'` adds the viewer's token and is refused for any host that is not IOSense's.
+
+Peer dependency: React 18 or later.

package/dist/IOSenseApp.d.ts

@@ -0,0 +1,37 @@
+import { type CSSProperties, type ReactNode } from 'react';
+export interface IOSenseAppProps {
+    /** The app's name, for the sign-in screen. */
+    name: string;
+    /**
+     * `required` (the default): with no session, the sign-in screen instead of the app — an app on
+     * ontology data or IOSense's APIs needs the viewer's IOSense login. Opened from the IOSense
+     * launchpad the session arrives on its own and the screen never shows.
+     * `optional`: the app opens without a session, and plant data is sample data.
+     * `none`: no IOSense sign-in at all (an app that asked for no SSO).
+     */
+    auth?: 'required' | 'optional' | 'none';
+    /** Force sample data on or off. Left out: sample exactly when there is no session. */
+    sample?: boolean;
+    /** IOSense's API host, when it is not production's. Same as `configure({ apiBaseUrl })`. */
+    apiBaseUrl?: string;
+    /** Shown instead of the built-in sign-in screen. Call `onSignedIn(bearer)` when you have a session. */
+    signIn?: (props: {
+        appName: string;
+        apiBaseUrl: string;
+        onSignedIn: (token: string) => void;
+    }) => ReactNode;
+    children: ReactNode;
+}
+/**
+ * The root of an IOSense app: the session, and the sign-in screen when there is none.
+ *
+ * The session comes the way IOSense hands it over — the launchpad's SSO token (exchanged before the
+ * first render), a bearer on the URL, the `.iosense.io` cookie, or one kept in this browser — and
+ * the token is taken out of the URL at once. It renders no chrome of its own.
+ */
+export declare function IOSenseApp({ name, auth, sample, apiBaseUrl, signIn, children }: IOSenseAppProps): import("react").JSX.Element | null;
+/** The badge an app shows while its data is sample data. Renders nothing on live data. */
+export declare function SampleBadge({ className, style }: {
+    className?: string;
+    style?: CSSProperties;
+}): import("react").JSX.Element | null;

package/dist/IOSenseApp.js

@@ -0,0 +1,77 @@
+import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+import { useEffect, useMemo, useState } from 'react';
+import { adoptHostSession, clearToken, exchangeSsoToken, getToken, setToken, takePendingSsoToken } from './auth.js';
+import { configure, getConfig } from './config.js';
+import { publishSession } from './request.js';
+import { SAMPLE_NOTICE, SessionContext, useIOSense } from './session.js';
+import { SignIn } from './SignIn.js';
+/**
+ * The root of an IOSense app: the session, and the sign-in screen when there is none.
+ *
+ * The session comes the way IOSense hands it over — the launchpad's SSO token (exchanged before the
+ * first render), a bearer on the URL, the `.iosense.io` cookie, or one kept in this browser — and
+ * the token is taken out of the URL at once. It renders no chrome of its own.
+ */
+export function IOSenseApp({ name, auth = 'required', sample, apiBaseUrl, signIn, children }) {
+    if (apiBaseUrl)
+        configure({ apiBaseUrl });
+    const api = getConfig().apiBaseUrl;
+    // Once, before the first child renders, so the first paint already has the session.
+    const [phase, setPhase] = useState(() => {
+        if (auth === 'none')
+            return { kind: 'ready', token: null };
+        adoptHostSession();
+        const sso = takePendingSsoToken();
+        return sso ? { kind: 'exchanging', sso } : { kind: 'ready', token: getToken() };
+    });
+    useEffect(() => {
+        if (phase.kind !== 'exchanging')
+            return;
+        let current = true;
+        exchangeSsoToken(phase.sso).then((token) => {
+            setToken(token);
+            if (current)
+                setPhase({ kind: 'ready', token });
+        }, () => {
+            // A refused SSO token is the same as none: the sign-in screen, or sample data.
+            if (current)
+                setPhase({ kind: 'ready', token: getToken() });
+        });
+        return () => {
+            current = false;
+        };
+    }, [phase]);
+    const token = phase.kind === 'ready' ? phase.token : null;
+    const session = useMemo(() => ({
+        appName: name,
+        token,
+        apiBaseUrl: api,
+        sample: sample ?? (auth !== 'none' && !token),
+        sampleNotice: SAMPLE_NOTICE,
+        signOut: () => {
+            clearToken();
+            setPhase({ kind: 'ready', token: null });
+        },
+    }), [name, token, api, sample, auth]);
+    // For `request()`, which is called from event handlers where there is no hook to read from.
+    publishSession({ token, apiBaseUrl: api });
+    // A blank moment while the SSO token is exchanged: not the sign-in screen, which would be wrong
+    // for the half second before the session lands.
+    if (phase.kind === 'exchanging')
+        return null;
+    if (auth === 'required' && !token) {
+        const onSignedIn = (bearer) => {
+            setToken(bearer);
+            setPhase({ kind: 'ready', token: getToken() });
+        };
+        return _jsx(_Fragment, { children: signIn ? signIn({ appName: name, apiBaseUrl: api, onSignedIn }) : _jsx(SignIn, { appName: name, apiBaseUrl: api, onSignedIn: onSignedIn }) });
+    }
+    return _jsx(SessionContext.Provider, { value: session, children: children });
+}
+/** The badge an app shows while its data is sample data. Renders nothing on live data. */
+export function SampleBadge({ className, style }) {
+    const { sample, sampleNotice } = useIOSense();
+    if (!sample)
+        return null;
+    return (_jsx("span", { "data-iosense-sample": true, className: className, style: className ? style : { display: 'inline-block', padding: '2px 8px', borderRadius: 6, background: '#fef3c7', color: '#78350f', fontSize: 12, fontWeight: 500, ...style }, children: sampleNotice }));
+}

package/dist/SignIn.d.ts

@@ -0,0 +1,24 @@
+/**
+ * The SDK's sign-in screen: what an app shows when it needs an IOSense session and has none.
+ *
+ * An app opened from the IOSense launchpad never sees this — the launchpad hands the session over
+ * (cookie mode sets `AccessToken` on `.iocompute.ai` through `secure.iocompute.ai/set-and-redirect`;
+ * SSO mode puts `?token=` on the URL) and `IOSenseApp` picks it up before the first paint. Inside the
+ * Studio the frame shares the Studio's origin and reads its token. This screen is for the third
+ * case: the app's own address, opened directly, by someone who has an IOSense session elsewhere.
+ *
+ * It takes a token, not a username and a password. An app is not IOSense: a password typed into an
+ * app's page is a password handed to whatever that page runs, and accounts with a second factor
+ * could not sign in here at all. What it wants is an IOSense SSO token — the 64-character one
+ * `generate-sso-token` mints, the same thing the launchpad hands over — which it exchanges for the
+ * session (`exchangeSsoToken`) and keeps the same way (`setToken`). A bearer pasted instead is
+ * taken too, after one request checks that IOSense accepts it: a wrong paste is one line here
+ * instead of an app full of failed requests.
+ *
+ * Plain markup and the theme's tokens, so it looks like the app it opens, whatever the app's own CSS.
+ */
+export declare function SignIn({ appName, apiBaseUrl, onSignedIn }: {
+    appName: string;
+    apiBaseUrl: string;
+    onSignedIn: (token: string) => void;
+}): import("react").JSX.Element;

package/dist/SignIn.js

@@ -0,0 +1,72 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { useState } from 'react';
+import { exchangeSsoToken, isSsoToken } from './auth.js';
+/**
+ * The SDK's sign-in screen: what an app shows when it needs an IOSense session and has none.
+ *
+ * An app opened from the IOSense launchpad never sees this — the launchpad hands the session over
+ * (cookie mode sets `AccessToken` on `.iocompute.ai` through `secure.iocompute.ai/set-and-redirect`;
+ * SSO mode puts `?token=` on the URL) and `IOSenseApp` picks it up before the first paint. Inside the
+ * Studio the frame shares the Studio's origin and reads its token. This screen is for the third
+ * case: the app's own address, opened directly, by someone who has an IOSense session elsewhere.
+ *
+ * It takes a token, not a username and a password. An app is not IOSense: a password typed into an
+ * app's page is a password handed to whatever that page runs, and accounts with a second factor
+ * could not sign in here at all. What it wants is an IOSense SSO token — the 64-character one
+ * `generate-sso-token` mints, the same thing the launchpad hands over — which it exchanges for the
+ * session (`exchangeSsoToken`) and keeps the same way (`setToken`). A bearer pasted instead is
+ * taken too, after one request checks that IOSense accepts it: a wrong paste is one line here
+ * instead of an app full of failed requests.
+ *
+ * Plain markup and the theme's tokens, so it looks like the app it opens, whatever the app's own CSS.
+ */
+export function SignIn({ appName, apiBaseUrl, onSignedIn }) {
+    const [token, setToken] = useState('');
+    const [busy, setBusy] = useState(false);
+    const [error, setError] = useState(null);
+    async function submit(event) {
+        event.preventDefault();
+        // A token copied from a URL may carry `Bearer ` or quotes; what IOSense wants is the value alone.
+        const value = token.trim().replace(/^Bearer\s+/i, '').replace(/^["']|["']$/g, '');
+        if (!value)
+            return;
+        setBusy(true);
+        setError(null);
+        if (isSsoToken(value)) {
+            try {
+                const bearer = await exchangeSsoToken(value);
+                setToken('');
+                onSignedIn(bearer);
+            }
+            catch (err) {
+                // The server's own words ("Invalid or expired token.") say what to do: mint a new one.
+                setError(`${err instanceof Error ? err.message : 'IOSense did not accept this token.'} An SSO token works once — copy a fresh one.`);
+            }
+            finally {
+                setBusy(false);
+            }
+            return;
+        }
+        try {
+            // The call IOSense itself makes for the signed-in account (auth.service.ts): a 401 is a clear no.
+            const res = await fetch(`${apiBaseUrl}/api/account/getUserDetails2`, { headers: { Authorization: `Bearer ${value}` } });
+            // Only a clear "no" stops the sign-in. Any other answer — the route moved, the server is
+            // down — lets the app open; its own requests will say what is wrong, and a token that is
+            // right should never be refused by a check that could not run.
+            if (res.status === 401 || res.status === 403) {
+                setError('IOSense did not accept this token. Copy a fresh one from a signed-in IOSense session.');
+                return;
+            }
+        }
+        catch {
+            // Unreachable: the app opens, and shows the reach problem where it shows its data.
+        }
+        finally {
+            setBusy(false);
+        }
+        setToken('');
+        onSignedIn(value);
+    }
+    const canSubmit = !busy && token.trim().length > 0;
+    return (_jsx("div", { "data-iosense-signin": true, style: { minHeight: '100vh', display: 'grid', placeItems: 'center', padding: 24, background: 'var(--background, #f7f7f4)', color: 'var(--foreground, #161616)', fontFamily: 'inherit' }, children: _jsxs("form", { onSubmit: submit, style: { width: 'min(380px, 100%)', display: 'flex', flexDirection: 'column', gap: 12, padding: 24, borderRadius: 12, background: 'var(--card, #fff)', border: '1px solid var(--border, #e2e0da)' }, children: [_jsxs("div", { children: [_jsxs("h1", { style: { margin: 0, fontSize: 18, fontWeight: 600 }, children: ["Sign in to ", appName] }), _jsx("p", { style: { margin: '4px 0 0', fontSize: 13, color: 'var(--muted-foreground, #5c5c5c)' }, children: "This app reads your plant through IOSense. Paste an SSO token from your IOSense session." })] }), _jsxs("label", { style: { display: 'flex', flexDirection: 'column', gap: 4, fontSize: 13, fontWeight: 500 }, children: ["SSO token", _jsx("input", { name: "token", autoComplete: "off", autoFocus: true, spellCheck: false, placeholder: "Paste an SSO token from IOSense", value: token, onChange: (e) => setToken(e.target.value), disabled: busy, style: { width: '100%', boxSizing: 'border-box', height: 40, padding: '0 12px', border: '1px solid var(--border, #d4d4d8)', borderRadius: 8, background: 'var(--background, #fff)', color: 'inherit', font: 'inherit' } })] }), error && (_jsx("p", { role: "alert", style: { margin: 0, fontSize: 13, color: 'var(--destructive, #b4302c)' }, children: error })), _jsx("button", { type: "submit", disabled: !canSubmit, style: { height: 40, border: 0, borderRadius: 999, background: 'var(--primary, #1364f1)', color: 'var(--primary-foreground, #fff)', font: 'inherit', fontWeight: 500, cursor: busy ? 'progress' : 'pointer', opacity: canSubmit ? 1 : 0.6 }, children: busy ? 'Checking…' : 'Continue' }), _jsx("p", { style: { margin: 0, fontSize: 12, color: 'var(--muted-foreground, #5c5c5c)' }, children: "Opened from the IOSense launchpad, this app signs you in on its own \u2014 this screen is for opening it by its own address." })] }) }));
+}

package/dist/auth.d.ts

@@ -0,0 +1,22 @@
+/** A launchpad SSO token: 64 hex characters. A bearer is a JWT, far longer and with dots. */
+export declare function isSsoToken(value: string): boolean;
+/**
+ * Turn an SSO token into the session it stands for. IOSense answers each SSO token once; the
+ * exchange is shared per token (React's StrictMode runs effects twice), and only a failed one is
+ * forgotten. Resolves with the bearer, without its `Bearer ` prefix.
+ */
+export declare function exchangeSsoToken(sso: string): Promise<string>;
+/** The SSO token the URL handed over, once. */
+export declare function takePendingSsoToken(): string | null;
+/** The bearer of the signed-in viewer, or null. */
+export declare function getToken(): string | null;
+export declare function setToken(token: string): void;
+/** Sign out in this browser: the session is forgotten. */
+export declare function clearToken(): void;
+/** True when this page runs inside another page's frame — the IOSense launchpad, normally. */
+export declare function isEmbedded(): boolean;
+/**
+ * Take the session the host handed over, and take the token out of the URL. Called once, before
+ * the first render (`<IOSenseApp>` does it). Returns how the session arrived.
+ */
+export declare function adoptHostSession(): 'sso' | 'url' | 'cookie' | 'stored' | 'none';

package/dist/auth.js

@@ -0,0 +1,135 @@
+import { getConfig } from './config.js';
+/**
+ * The IOSense session: how an app gets it, and where it keeps it.
+ *
+ * Four ways in, in order:
+ *  1. **Launchpad, SSO mode** — IOSense opens the app as `…?token=<sso>`: a 64-hex SSO token,
+ *     exchanged ONCE for the bearer (`exchangeSsoToken`) before the app renders.
+ *  2. **A bearer on the URL** (`?token=<jwt>`), taken as it is.
+ *  3. **Launchpad, cookie mode** — the access token as a cookie on `.iosense.io`.
+ *  4. **Stored** — a session kept in this browser from before, or the sign-in screen.
+ *
+ * The token is taken out of the URL at once: a token in the address is copied into bookmarks,
+ * shared links and `Referer` headers. It lives in memory first and localStorage second; storage in a
+ * cross-site iframe can be partitioned or blocked, so it is only ever best effort.
+ */
+const TOKEN_PARAM = 'token';
+let memoryToken = null;
+let pendingSso = null;
+/** A launchpad SSO token: 64 hex characters. A bearer is a JWT, far longer and with dots. */
+export function isSsoToken(value) {
+    return /^[0-9a-f]{64}$/i.test(value.trim());
+}
+const exchanges = new Map();
+/**
+ * Turn an SSO token into the session it stands for. IOSense answers each SSO token once; the
+ * exchange is shared per token (React's StrictMode runs effects twice), and only a failed one is
+ * forgotten. Resolves with the bearer, without its `Bearer ` prefix.
+ */
+export function exchangeSsoToken(sso) {
+    const key = sso.trim();
+    let inFlight = exchanges.get(key);
+    if (!inFlight) {
+        inFlight = (async () => {
+            const res = await fetch(`${getConfig().ssoExchangeUrl}/${encodeURIComponent(key)}`);
+            const body = (await res.json().catch(() => null));
+            if (!body?.success || !body.token) {
+                const said = body?.errors?.[0];
+                throw new Error(typeof said === 'string' ? said : `IOSense did not accept the SSO token (${res.status}).`);
+            }
+            return body.token.replace(/^Bearer\s+/i, '');
+        })();
+        exchanges.set(key, inFlight);
+        inFlight.catch(() => exchanges.delete(key));
+    }
+    return inFlight;
+}
+/** The SSO token the URL handed over, once. */
+export function takePendingSsoToken() {
+    const sso = pendingSso;
+    pendingSso = null;
+    return sso;
+}
+function readStored() {
+    try {
+        return localStorage.getItem(getConfig().storageKey);
+    }
+    catch {
+        return null;
+    }
+}
+/** The bearer of the signed-in viewer, or null. */
+export function getToken() {
+    if (memoryToken)
+        return memoryToken;
+    memoryToken = readStored();
+    return memoryToken;
+}
+export function setToken(token) {
+    memoryToken = token.replace(/^Bearer\s+/i, '');
+    try {
+        localStorage.setItem(getConfig().storageKey, memoryToken);
+    }
+    catch {
+        // The session still works for as long as this page lives.
+    }
+}
+/** Sign out in this browser: the session is forgotten. */
+export function clearToken() {
+    memoryToken = null;
+    try {
+        localStorage.removeItem(getConfig().storageKey);
+    }
+    catch {
+        // Nothing more to do: the in-memory copy is gone, and that is what the app reads.
+    }
+}
+/** True when this page runs inside another page's frame — the IOSense launchpad, normally. */
+export function isEmbedded() {
+    try {
+        return window.self !== window.top;
+    }
+    catch {
+        return true;
+    }
+}
+function readCookie(name) {
+    const prefix = `${name}=`;
+    for (const part of document.cookie.split(';')) {
+        const entry = part.trim();
+        if (entry.startsWith(prefix))
+            return decodeURIComponent(entry.slice(prefix.length));
+    }
+    return null;
+}
+/**
+ * Take the session the host handed over, and take the token out of the URL. Called once, before
+ * the first render (`<IOSenseApp>` does it). Returns how the session arrived.
+ */
+export function adoptHostSession() {
+    if (typeof window === 'undefined')
+        return 'none';
+    const url = new URL(window.location.href);
+    const hash = new URLSearchParams(url.hash.replace(/^#/, ''));
+    const handed = url.searchParams.get(TOKEN_PARAM) ?? hash.get(TOKEN_PARAM);
+    if (handed?.trim()) {
+        // IOSense builds the iframe URL without encoding it, so a `+` in a token arrives as a space.
+        const value = handed.trim().replaceAll(' ', '+');
+        const sso = isSsoToken(value);
+        if (sso)
+            pendingSso = value;
+        else
+            setToken(value);
+        url.searchParams.delete(TOKEN_PARAM);
+        hash.delete(TOKEN_PARAM);
+        const rest = hash.toString();
+        window.history.replaceState(window.history.state, '', `${url.pathname}${url.search}${rest ? `#${rest}` : ''}`);
+        return sso ? 'sso' : 'url';
+    }
+    const cookie = readCookie(getConfig().tokenCookie);
+    if (cookie?.trim()) {
+        setToken(cookie.trim());
+        return 'cookie';
+    }
+    return getToken() ? 'stored' : 'none';
+}

package/dist/config.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Where IOSense is. The defaults are IOSense's production hosts; an app on another region or a
+ * staging stack sets them once, before rendering (`configure({ apiBaseUrl: … })`), or passes
+ * `apiBaseUrl` to `<IOSenseApp>`.
+ */
+export interface IOSenseConfig {
+    /** IOSense's API host. Default `https://appserver.iosense.io`. */
+    apiBaseUrl: string;
+    /** Where a launchpad SSO token is exchanged for a session. */
+    ssoExchangeUrl: string;
+    /** Cookie mode's name for the access token on `.iosense.io`. */
+    tokenCookie: string;
+    /** Where the session is kept in this browser. */
+    storageKey: string;
+}
+export declare function configure(next: Partial<IOSenseConfig>): void;
+export declare const getConfig: () => Readonly<IOSenseConfig>;

package/dist/config.js

@@ -0,0 +1,13 @@
+const config = {
+    apiBaseUrl: 'https://appserver.iosense.io',
+    ssoExchangeUrl: 'https://connector.iosense.io/api/retrieve-sso-token',
+    tokenCookie: 'AccessToken',
+    storageKey: 'bearer_token',
+};
+export function configure(next) {
+    for (const [key, value] of Object.entries(next)) {
+        if (typeof value === 'string' && value)
+            config[key] = key.endsWith('Url') ? value.replace(/\/$/, '') : value;
+    }
+}
+export const getConfig = () => config;

package/dist/data.d.ts

@@ -0,0 +1,35 @@
+/**
+ * UNS reads: the latest value of a topic, and its values over a window.
+ *
+ * A topic is `uns:<workspace>://<path>[:<aggregation>]` — the same string io-lens dashboards bind
+ * widgets to (`uns:ws_1://plant/kiln/feed:last`, `…/power:average`). The read is IOSense's
+ * `resolveAndCompute`, the one dashboards make. Sample topics (`uns:design://…`), and every topic
+ * while the app shows sample data, are answered here with steady made-up values, so a screen can be
+ * built and shown before it is bound to a plant.
+ */
+export interface SeriesPoint {
+    from: number;
+    to: number;
+    label?: string;
+    value: number | null;
+}
+export declare const isSampleTopic: (topic: string) => boolean;
+export declare function noteTopics(topics: readonly string[]): void;
+/** The same read asked for within a second by two components (or StrictMode) is one request. */
+export declare function sharedRead<T>(key: string, read: () => Promise<T>, now?: number): Promise<T>;
+/** The latest value of each topic, in one request. */
+export declare function fetchLatest(topics: string[], opts: {
+    apiBaseUrl: string;
+    token: string | null;
+    sample: boolean;
+}): Promise<Record<string, unknown>>;
+/** Each topic's values over a window, bucketed. The topic's suffix is the aggregation. */
+export declare function fetchSeries(topics: string[], window: {
+    startTime: number;
+    endTime: number;
+    timeFrame: string;
+}, opts: {
+    apiBaseUrl: string;
+    token: string | null;
+    sample: boolean;
+}): Promise<Record<string, SeriesPoint[]>>;

package/dist/data.js

@@ -0,0 +1,135 @@
+/**
+ * UNS reads: the latest value of a topic, and its values over a window.
+ *
+ * A topic is `uns:<workspace>://<path>[:<aggregation>]` — the same string io-lens dashboards bind
+ * widgets to (`uns:ws_1://plant/kiln/feed:last`, `…/power:average`). The read is IOSense's
+ * `resolveAndCompute`, the one dashboards make. Sample topics (`uns:design://…`), and every topic
+ * while the app shows sample data, are answered here with steady made-up values, so a screen can be
+ * built and shown before it is bound to a plant.
+ */
+const RESOLVE = '/api/account/uns/resolveAndCompute';
+export const isSampleTopic = (topic) => topic.startsWith('uns:design://');
+/* ---------- topics a page reads (the Studio's preview listens) ---------- */
+const topicsRead = new Set();
+export function noteTopics(topics) {
+    const fresh = topics.filter((t) => !topicsRead.has(t));
+    if (!fresh.length)
+        return;
+    fresh.forEach((t) => topicsRead.add(t));
+    // An io-lens Studio preview lists the tags an app reads, to check that they report.
+    globalThis.__iolensTopics?.([...topicsRead]);
+}
+/* ---------- reads in flight, shared ---------- */
+const inFlight = new Map();
+const SHARE_MS = 1000;
+/** The same read asked for within a second by two components (or StrictMode) is one request. */
+export function sharedRead(key, read, now = Date.now()) {
+    const hit = inFlight.get(key);
+    if (hit && now - hit.at < SHARE_MS)
+        return hit.promise;
+    const promise = read();
+    inFlight.set(key, { at: now, promise });
+    promise.finally(() => setTimeout(() => inFlight.get(key)?.promise === promise && inFlight.delete(key), SHARE_MS)).catch(() => undefined);
+    return promise;
+}
+/* ---------- sample values ---------- */
+function hash(text) {
+    let h = 2166136261;
+    for (let i = 0; i < text.length; i++)
+        h = Math.imul(h ^ text.charCodeAt(i), 16777619);
+    return h >>> 0;
+}
+function sampleValue(topic) {
+    const seed = hash(topic);
+    return Math.round((40 + (seed % 55) + (seed % 10)) * 10) / 10;
+}
+function sampleSeries(topic, from, to, buckets) {
+    const seed = hash(topic);
+    const base = 40 + (seed % 55);
+    const amp = 8 + (seed % 12);
+    const step = Math.max(60000, Math.floor((to - from) / buckets));
+    return Array.from({ length: buckets }, (_, i) => {
+        const start = from + i * step;
+        const d = new Date(start);
+        return { from: start, to: start + step, label: `${String(d.getHours()).padStart(2, '0')}:00`, value: Math.round((base + amp * Math.sin((i + (seed % 7)) / 3)) * 10) / 10 };
+    });
+}
+/* ---------- the read ---------- */
+function body(config, startTime, endTime, timeFrame) {
+    return {
+        cycleYear: 'calendar',
+        yearStart: 1,
+        monthStart: 1,
+        weekStart: 0,
+        cycleTime: '00:00',
+        cycleTimeIdentifier: 'start',
+        shifts: [],
+        shiftAggregator: null,
+        disableClipping: false,
+        config,
+        startTime,
+        endTime,
+        timeFrame,
+        timezone: Intl.DateTimeFormat().resolvedOptions().timeZone || 'UTC',
+        inExactMultiple: false,
+    };
+}
+async function resolve(apiBaseUrl, token, payload) {
+    const res = await fetch(`${apiBaseUrl}${RESOLVE}`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', ...(token ? { Authorization: `Bearer ${token}` } : {}) },
+        body: JSON.stringify(payload),
+    });
+    if (!res.ok)
+        throw new Error(`IOSense answered ${res.status} to a data read.`);
+    const json = (await res.json());
+    const data = Array.isArray(json) ? json : json.data;
+    if (json && typeof json === 'object' && !Array.isArray(json) && json.success === false) {
+        throw new Error(String(json.message ?? 'IOSense refused the data read.'));
+    }
+    return Array.isArray(data) ? data : [];
+}
+/** The latest value of each topic, in one request. */
+export async function fetchLatest(topics, opts) {
+    const out = {};
+    const real = [];
+    for (const topic of topics) {
+        if (opts.sample || isSampleTopic(topic))
+            out[topic] = sampleValue(topic);
+        else
+            real.push(topic);
+    }
+    if (!real.length)
+        return out;
+    const now = Date.now();
+    const entries = await resolve(opts.apiBaseUrl, opts.token, body(real.map((topic) => ({ key: topic, topic })), now - 24 * 3600000, now, 'hour'));
+    for (const topic of real)
+        out[topic] = null;
+    for (const e of entries)
+        if (e && typeof e.key === 'string')
+            out[e.key] = e.value ?? null;
+    return out;
+}
+/** Each topic's values over a window, bucketed. The topic's suffix is the aggregation. */
+export async function fetchSeries(topics, window, opts) {
+    const out = {};
+    const real = [];
+    const buckets = Math.max(1, Math.min(200, Math.round((window.endTime - window.startTime) / ({ minute: 60e3, hour: 3600e3, day: 86400e3, week: 604800e3, month: 2592000e3 }[window.timeFrame] ?? 3600e3))));
+    for (const topic of topics) {
+        if (opts.sample || isSampleTopic(topic))
+            out[topic] = sampleSeries(topic, window.startTime, window.endTime, buckets);
+        else
+            real.push(topic);
+    }
+    if (!real.length)
+        return out;
+    const entries = await resolve(opts.apiBaseUrl, opts.token, body(real.map((topic) => ({ key: topic, topic, type: 'series' })), window.startTime, window.endTime, window.timeFrame));
+    for (const topic of real)
+        out[topic] = [];
+    for (const e of entries) {
+        if (!e || typeof e.key !== 'string' || !Array.isArray(e.slots))
+            continue;
+        out[e.key] = e.slots.map((s) => ({ from: Number(s.from), to: Number(s.to), ...(s.label ? { label: String(s.label) } : {}), value: s.value == null || s.value === '' ? null : Number(s.value) }));
+    }
+    return out;
+}

package/dist/hooks.d.ts

@@ -0,0 +1,50 @@
+import { type SeriesPoint } from './data.js';
+export interface LatestOptions {
+    /** Poll interval. Default 60 s; 0 reads once. */
+    refreshMs?: number;
+}
+export interface LatestResult {
+    /** Topic → its latest value. Absent until the first read; null when the plant has none. */
+    data: Record<string, unknown>;
+    loading: boolean;
+    error: Error | null;
+    /** Read again now. */
+    refresh: () => void;
+}
+/** The latest value of each UNS topic, polled. */
+export declare function useLatest(topics: readonly string[], options?: LatestOptions): LatestResult;
+export interface SeriesOptions {
+    /** How far back from now. Default 24. */
+    hours?: number;
+    /** Bucket size. Default 'hour'. */
+    bucket?: 'minute' | 'hour' | 'day' | 'week' | 'month';
+    /** Poll interval. Default 5 minutes; 0 reads once. */
+    refreshMs?: number;
+}
+export interface SeriesResult {
+    /** Topic → its points, oldest first. */
+    data: Record<string, SeriesPoint[]>;
+    loading: boolean;
+    error: Error | null;
+    refresh: () => void;
+}
+/** Each UNS topic's values over the last hours — for a trend, a table or a sparkline. */
+export declare function useSeries(topics: readonly string[], options?: SeriesOptions): SeriesResult;
+/** Who is signed in. IOSense has no named roles; gate on organisation, or your own list of ids or emails. */
+export interface IOSenseUser {
+    id: string;
+    email: string;
+    name: string;
+    organisation: {
+        id: string;
+        name: string;
+    };
+}
+export interface UserResult {
+    /** Null until read and while nobody is signed in; a sample user while the app shows sample data. */
+    user: IOSenseUser | null;
+    loading: boolean;
+    error: Error | null;
+}
+/** The signed-in viewer: id, email, name, organisation. */
+export declare function useUser(): UserResult;

package/dist/hooks.js

@@ -0,0 +1,135 @@
+import { useCallback, useEffect, useRef, useState } from 'react';
+import { fetchLatest, fetchSeries, noteTopics, sharedRead } from './data.js';
+import { requestWith } from './request.js';
+import { useIOSense } from './session.js';
+/** The latest value of each UNS topic, polled. */
+export function useLatest(topics, options = {}) {
+    const { apiBaseUrl, token, sample } = useIOSense();
+    const refreshMs = options.refreshMs ?? 60000;
+    const key = topics.join('\n');
+    const [data, setData] = useState({});
+    const [loading, setLoading] = useState(true);
+    const [error, setError] = useState(null);
+    const generation = useRef(0);
+    const read = useCallback(() => {
+        const wanted = key ? key.split('\n') : [];
+        if (!wanted.length) {
+            setData({});
+            setLoading(false);
+            return;
+        }
+        const mine = ++generation.current;
+        noteTopics(wanted);
+        sharedRead(`latest\u0000${apiBaseUrl}\u0000${token ?? ''}\u0000${sample ? 1 : 0}\u0000${key}`, () => fetchLatest(wanted, { apiBaseUrl, token, sample }))
+            .then((values) => {
+            if (mine !== generation.current)
+                return;
+            setData(values);
+            setError(null);
+        })
+            .catch((e) => {
+            if (mine === generation.current)
+                setError(e instanceof Error ? e : new Error(String(e)));
+        })
+            .finally(() => {
+            if (mine === generation.current)
+                setLoading(false);
+        });
+    }, [key, apiBaseUrl, token, sample]);
+    useEffect(() => {
+        setLoading(true);
+        read();
+        if (!refreshMs)
+            return;
+        const timer = setInterval(read, refreshMs);
+        return () => clearInterval(timer);
+    }, [read, refreshMs]);
+    return { data, loading, error, refresh: read };
+}
+/** Each UNS topic's values over the last hours — for a trend, a table or a sparkline. */
+export function useSeries(topics, options = {}) {
+    const { apiBaseUrl, token, sample } = useIOSense();
+    const hours = options.hours ?? 24;
+    const bucket = options.bucket ?? 'hour';
+    const refreshMs = options.refreshMs ?? 300000;
+    const key = topics.join('\n');
+    const [data, setData] = useState({});
+    const [loading, setLoading] = useState(true);
+    const [error, setError] = useState(null);
+    const generation = useRef(0);
+    const read = useCallback(() => {
+        const wanted = key ? key.split('\n') : [];
+        if (!wanted.length) {
+            setData({});
+            setLoading(false);
+            return;
+        }
+        const mine = ++generation.current;
+        noteTopics(wanted);
+        const endTime = Math.floor(Date.now() / 60000) * 60000;
+        const window = { startTime: endTime - hours * 3600000, endTime, timeFrame: bucket };
+        sharedRead(`series\u0000${apiBaseUrl}\u0000${token ?? ''}\u0000${sample ? 1 : 0}\u0000${hours}\u0000${bucket}\u0000${endTime}\u0000${key}`, () => fetchSeries(wanted, window, { apiBaseUrl, token, sample }))
+            .then((values) => {
+            if (mine !== generation.current)
+                return;
+            setData(values);
+            setError(null);
+        })
+            .catch((e) => {
+            if (mine === generation.current)
+                setError(e instanceof Error ? e : new Error(String(e)));
+        })
+            .finally(() => {
+            if (mine === generation.current)
+                setLoading(false);
+        });
+    }, [key, apiBaseUrl, token, sample, hours, bucket]);
+    useEffect(() => {
+        setLoading(true);
+        read();
+        if (!refreshMs)
+            return;
+        const timer = setInterval(read, refreshMs);
+        return () => clearInterval(timer);
+    }, [read, refreshMs]);
+    return { data, loading, error, refresh: read };
+}
+const SAMPLE_USER = { id: 'sample', email: 'sample.user@example.com', name: 'Sample user', organisation: { id: 'sample', name: 'Sample plant' } };
+const userReads = new Map();
+function readUser(token, apiBaseUrl) {
+    const key = `${apiBaseUrl}\u0000${token}`;
+    let read = userReads.get(key);
+    if (!read) {
+        // `getUserDetails2`, never `getUserDetails`: the older one also returns credential fields.
+        read = requestWith(token, apiBaseUrl, `${apiBaseUrl}/api/account/getUserDetails2`, { auth: 'iosense' }).then((body) => {
+            const u = body?.data?.user;
+            if (!u?.id)
+                throw new Error('IOSense did not say who is signed in.');
+            const name = [u.userDetail?.personalDetails?.name?.first, u.userDetail?.personalDetails?.name?.last].filter(Boolean).join(' ').trim();
+            return { id: u.id, email: u.email ?? '', name: name || u.email || '', organisation: { id: u.organisation?._id ?? '', name: u.organisation?.orgName ?? '' } };
+        });
+        userReads.set(key, read);
+        read.catch(() => userReads.delete(key));
+    }
+    return read;
+}
+/** The signed-in viewer: id, email, name, organisation. */
+export function useUser() {
+    const { token, apiBaseUrl, sample } = useIOSense();
+    const [state, setState] = useState({ user: sample ? SAMPLE_USER : null, loading: !sample && !!token, error: null });
+    useEffect(() => {
+        if (sample)
+            return setState({ user: SAMPLE_USER, loading: false, error: null });
+        if (!token)
+            return setState({ user: null, loading: false, error: null });
+        let live = true;
+        setState((s) => ({ ...s, loading: true }));
+        readUser(token, apiBaseUrl)
+            .then((user) => live && setState({ user, loading: false, error: null }))
+            .catch((e) => live && setState({ user: null, loading: false, error: e instanceof Error ? e : new Error(String(e)) }));
+        return () => {
+            live = false;
+        };
+    }, [token, apiBaseUrl, sample]);
+    return state;
+}

package/dist/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @faclon-labs/app-sdk — IOSense sign-in and plant data for React apps.
+ *
+ * Wrap the app in `<IOSenseApp>`: it takes the session IOSense hands over (the launchpad's SSO
+ * token, a bearer on the URL, the `.iosense.io` cookie) or shows a sign-in screen, and gives every
+ * component the viewer's session. Then read UNS topics with `useLatest` / `useSeries`, the viewer
+ * with `useUser`, and call IOSense's APIs with `request(url, { auth: 'iosense' })`.
+ */
+export { IOSenseApp, SampleBadge, type IOSenseAppProps } from './IOSenseApp.js';
+export { useIOSense, SAMPLE_NOTICE, type IOSenseSession } from './session.js';
+export { SignIn } from './SignIn.js';
+export { useLatest, useSeries, useUser, type LatestOptions, type LatestResult, type SeriesOptions, type SeriesResult, type IOSenseUser, type UserResult } from './hooks.js';
+export { fetchLatest, fetchSeries, isSampleTopic, type SeriesPoint } from './data.js';
+export { request, useRequest, RequestError, isIOSenseHost, type RequestOptions, type UseRequestOptions, type UseRequestResult } from './request.js';
+export { configure, getConfig, type IOSenseConfig } from './config.js';
+export { adoptHostSession, exchangeSsoToken, getToken, setToken, clearToken, isSsoToken, isEmbedded } from './auth.js';

package/dist/index.js

@@ -0,0 +1,16 @@
+/**
+ * @faclon-labs/app-sdk — IOSense sign-in and plant data for React apps.
+ *
+ * Wrap the app in `<IOSenseApp>`: it takes the session IOSense hands over (the launchpad's SSO
+ * token, a bearer on the URL, the `.iosense.io` cookie) or shows a sign-in screen, and gives every
+ * component the viewer's session. Then read UNS topics with `useLatest` / `useSeries`, the viewer
+ * with `useUser`, and call IOSense's APIs with `request(url, { auth: 'iosense' })`.
+ */
+export { IOSenseApp, SampleBadge } from './IOSenseApp.js';
+export { useIOSense, SAMPLE_NOTICE } from './session.js';
+export { SignIn } from './SignIn.js';
+export { useLatest, useSeries, useUser } from './hooks.js';
+export { fetchLatest, fetchSeries, isSampleTopic } from './data.js';
+export { request, useRequest, RequestError, isIOSenseHost } from './request.js';
+export { configure, getConfig } from './config.js';
+export { adoptHostSession, exchangeSsoToken, getToken, setToken, clearToken, isSsoToken, isEmbedded } from './auth.js';

package/dist/request.d.ts

@@ -0,0 +1,56 @@
+/**
+ * An app's own requests: any API, from the app's code.
+ *
+ * Plant data comes through `useLatest` and the widgets, but an app is more than plant data — a
+ * maintenance system, an ERP, a weather service, the app's own backend. `request` is `fetch` with
+ * the two things every such call wants: the body as JSON in and out, and an error when the server
+ * says no. `useRequest` is the same as a hook, with loading and error states, so a screen that reads
+ * an API is three lines rather than thirty. Plain `fetch` is allowed too; these are conveniences.
+ *
+ * **The login token goes only where it belongs.** `auth: 'iosense'` adds the viewer's IOSense token
+ * — needed for IOSense's own APIs — and is refused for any other host, so an app cannot be talked
+ * into sending the token somewhere else. Everything else is the browser's ordinary rules: a
+ * third-party API answers a page only if its CORS allows this origin (the Studio's while previewing,
+ * the app's own once deployed).
+ */
+export interface RequestOptions extends Omit<RequestInit, 'body'> {
+    /** Sent as JSON, with the content type set. A string or FormData goes as it is. */
+    body?: unknown;
+    /** `'iosense'`: add the viewer's IOSense token. Refused for a host that is not IOSense's. */
+    auth?: 'iosense';
+}
+export declare class RequestError extends Error {
+    status: number;
+    /** What the server sent back, parsed as JSON when it was JSON. */
+    body: unknown;
+    constructor(message: string, status: number, body: unknown);
+}
+/** Where the viewer's token may go: IOSense's API host, and IOSense's own domains. */
+export declare function isIOSenseHost(url: string, apiBaseUrl: string): boolean;
+export declare function requestWith(token: string | null, apiBaseUrl: string, url: string, options?: RequestOptions): Promise<unknown>;
+/** One request. Resolves with the parsed body; throws `RequestError` on a non-2xx answer. */
+export declare function request<T = unknown>(url: string, options?: RequestOptions): Promise<T>;
+export declare function publishSession(session: {
+    token: string | null;
+    apiBaseUrl: string;
+}): void;
+export interface UseRequestResult<T> {
+    data: T | undefined;
+    loading: boolean;
+    error: Error | null;
+    /** Ask again now. */
+    refresh: () => void;
+}
+export interface UseRequestOptions extends RequestOptions {
+    /** Ask again every so often. Default: once. */
+    refreshMs?: number;
+    /** False: do not ask yet (the URL is not ready, a form is not filled in). */
+    enabled?: boolean;
+}
+/**
+ * A request as a hook: asked when the component mounts, again when the URL changes.
+ *
+ * Options are compared as JSON, so `useRequest(url, { body: { mill } })` asks again when `mill`
+ * changes and not on every render.
+ */
+export declare function useRequest<T = unknown>(url: string | null | undefined, options?: UseRequestOptions): UseRequestResult<T>;

package/dist/request.js

@@ -0,0 +1,122 @@
+import { useCallback, useEffect, useRef, useState } from 'react';
+import { useIOSense } from './session.js';
+export class RequestError extends Error {
+    constructor(message, status, body) {
+        super(message);
+        this.status = status;
+        this.body = body;
+    }
+}
+/** Where the viewer's token may go: IOSense's API host, and IOSense's own domains. */
+export function isIOSenseHost(url, apiBaseUrl) {
+    try {
+        const host = new URL(url, typeof window === 'undefined' ? 'http://localhost/' : window.location.href).hostname.toLowerCase();
+        const api = new URL(apiBaseUrl).hostname.toLowerCase();
+        return host === api || host === 'iosense.io' || host.endsWith('.iosense.io');
+    }
+    catch {
+        return false;
+    }
+}
+async function parse(res) {
+    const type = res.headers.get('content-type') ?? '';
+    if (res.status === 204)
+        return null;
+    if (type.includes('application/json'))
+        return res.json().catch(() => null);
+    return res.text();
+}
+export async function requestWith(token, apiBaseUrl, url, options = {}) {
+    const { body, auth, headers, ...init } = options;
+    const h = new Headers(headers);
+    if (auth === 'iosense') {
+        if (!isIOSenseHost(url, apiBaseUrl))
+            throw new RequestError(`auth: 'iosense' is only for IOSense's own APIs, not ${url}`, 0, null);
+        if (token)
+            h.set('Authorization', `Bearer ${token}`);
+    }
+    let payload;
+    if (body !== undefined && body !== null) {
+        if (typeof body === 'string') {
+            // Already-encoded JSON is common (`body: JSON.stringify(x)`): send it as JSON, not as text.
+            payload = body;
+            if (!h.has('Content-Type')) {
+                try {
+                    JSON.parse(body);
+                    h.set('Content-Type', 'application/json');
+                }
+                catch {
+                    h.set('Content-Type', 'text/plain;charset=UTF-8');
+                }
+            }
+        }
+        else if (body instanceof FormData || body instanceof Blob || body instanceof URLSearchParams)
+            payload = body;
+        else {
+            payload = JSON.stringify(body);
+            if (!h.has('Content-Type'))
+                h.set('Content-Type', 'application/json');
+        }
+    }
+    if (!h.has('Accept'))
+        h.set('Accept', 'application/json, text/plain;q=0.9, */*;q=0.8');
+    const res = await fetch(url, { ...init, method: init.method ?? (payload === undefined ? 'GET' : 'POST'), headers: h, body: payload });
+    const data = await parse(res);
+    if (!res.ok) {
+        const said = typeof data === 'object' && data && typeof data.message === 'string' ? data.message : '';
+        throw new RequestError(said || `${url} answered ${res.status}`, res.status, data);
+    }
+    return data;
+}
+/** One request. Resolves with the parsed body; throws `RequestError` on a non-2xx answer. */
+export function request(url, options) {
+    return requestWith(readSession().token, readSession().apiBaseUrl, url, options);
+}
+// `request` is called from event handlers, outside React, so the session is read from the one the
+// nearest `IOSenseApp` published rather than from a hook.
+let current = { token: null, apiBaseUrl: '' };
+export function publishSession(session) {
+    current = session;
+}
+const readSession = () => current;
+/**
+ * A request as a hook: asked when the component mounts, again when the URL changes.
+ *
+ * Options are compared as JSON, so `useRequest(url, { body: { mill } })` asks again when `mill`
+ * changes and not on every render.
+ */
+export function useRequest(url, options = {}) {
+    const { token, apiBaseUrl } = useIOSense();
+    const { refreshMs = 0, enabled = true, ...rest } = options;
+    const optionsKey = JSON.stringify(rest);
+    const [data, setData] = useState();
+    const [loading, setLoading] = useState(Boolean(url) && enabled);
+    const [error, setError] = useState(null);
+    const generation = useRef(0);
+    const ask = useCallback(() => {
+        if (!url || !enabled)
+            return;
+        const mine = ++generation.current;
+        setLoading(true);
+        requestWith(token, apiBaseUrl, url, JSON.parse(optionsKey)).then((result) => {
+            if (mine !== generation.current)
+                return;
+            setData(result);
+            setError(null);
+            setLoading(false);
+        }, (err) => {
+            if (mine !== generation.current)
+                return;
+            setError(err instanceof Error ? err : new Error(String(err)));
+            setLoading(false);
+        });
+    }, [url, enabled, token, apiBaseUrl, optionsKey]);
+    useEffect(() => {
+        ask();
+        if (!refreshMs || !url || !enabled)
+            return;
+        const timer = setInterval(ask, refreshMs);
+        return () => clearInterval(timer);
+    }, [ask, refreshMs, url, enabled]);
+    return { data, loading, error, refresh: ask };
+}

package/dist/session.d.ts

@@ -0,0 +1,19 @@
+/** What every part of an app can ask about the session it runs in. */
+export interface IOSenseSession {
+    /** The app's display name. */
+    appName: string;
+    /** The signed-in viewer's bearer, or null when nobody is signed in. */
+    token: string | null;
+    /** IOSense's API host. */
+    apiBaseUrl: string;
+    /** True when the app shows generated sample data rather than the plant's (no session, or asked for). */
+    sample: boolean;
+    /** One sentence for a badge, so every app words it the same way. */
+    sampleNotice: string;
+    /** Forget the session in this browser and show the sign-in screen again. */
+    signOut: () => void;
+}
+export declare const SAMPLE_NOTICE = "Sample data \u2014 not live plant readings";
+export declare const SessionContext: import("react").Context<IOSenseSession | null>;
+/** The session of the nearest `<IOSenseApp>`. Throws outside one. */
+export declare function useIOSense(): IOSenseSession;

package/dist/session.js

@@ -0,0 +1,10 @@
+import { createContext, useContext } from 'react';
+export const SAMPLE_NOTICE = 'Sample data — not live plant readings';
+export const SessionContext = createContext(null);
+/** The session of the nearest `<IOSenseApp>`. Throws outside one. */
+export function useIOSense() {
+    const session = useContext(SessionContext);
+    if (!session)
+        throw new Error('useIOSense: wrap the app in <IOSenseApp>.');
+    return session;
+}

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@faclon-labs/app-sdk",
+  "version": "0.1.0",
+  "description": "IOSense sign-in and plant data for React apps: the launchpad SSO session, UNS latest values and series, the signed-in user, and requests to IOSense's APIs.",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "sideEffects": false,
+  "peerDependencies": {
+    "react": ">=18"
+  },
+  "keywords": [
+    "iosense",
+    "faclon",
+    "uns",
+    "react",
+    "sso"
+  ],
+  "license": "UNLICENSED",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "rm -rf dist && tsc -p tsconfig.json"
+  }
+}