@satinhq/kit 0.0.0-stage → 0.1.0-beta.0

package/dist/image/resource.js

@@ -0,0 +1,286 @@
+import { prepareMountedContent, hasPendingContent, imageRequiredForReveal, } from './contentReadiness.js';
+export const emptyImageSource = 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAACXBIWXMAAAPoAAAD6AG1e1JrAAAADUlEQVQImWNgYGBgAAAABQABh6FO1AAAAABJRU5ErkJggg==';
+const decoded = new Map();
+// A software retention limit, not a claim about WebKit's resident decoded memory.
+const retainedBytes = 32 * 1024 * 1024;
+const retainedFailures = 64;
+function trimDecoded() {
+    const entries = [...new Set(decoded.values())];
+    let failures = entries.filter(entry => entry.failed).length;
+    let bytes = entries.reduce((sum, entry) => sum + entry.bytes, 0);
+    for (const entry of entries) {
+        if (entry.failed && !entry.users && failures > retainedFailures) {
+            for (const [key, value] of decoded)
+                if (value === entry)
+                    decoded.delete(key);
+            failures--;
+        }
+        if (bytes <= retainedBytes)
+            continue;
+        if (!entry.ready || entry.users)
+            continue;
+        for (const [key, value] of decoded)
+            if (value === entry)
+                decoded.delete(key);
+        bytes -= entry.bytes;
+    }
+}
+function touch(entry) {
+    const keys = [...decoded].filter(([, value]) => value === entry).map(([key]) => key);
+    for (const key of keys)
+        decoded.delete(key);
+    for (const key of keys)
+        decoded.set(key, entry);
+}
+function sourceKey(url) {
+    return typeof document === 'undefined' ? url : new URL(url, document.baseURI).href;
+}
+export function imageRequestKey(url, request) {
+    return JSON.stringify([
+        sourceKey(url),
+        request.crossOrigin ?? null,
+        request.referrerPolicy ?? '',
+        request.srcSet ?? '',
+        request.sizes ?? '',
+        request.srcSet ? globalThis.innerWidth : 0,
+        request.srcSet ? globalThis.innerHeight : 0,
+        request.srcSet ? globalThis.devicePixelRatio : 0,
+    ]);
+}
+export function peekDecodedImage(url, request = {}) {
+    const entry = decoded.get(imageRequestKey(url, request));
+    if (entry)
+        touch(entry);
+    return entry?.ready ? entry.image : undefined;
+}
+/** Failed requests settle content admission too. Remember the outcome across
+ * suspended React retries, which may reconstruct a preparation before it commits. */
+export function imageDecodeFailed(url, request = {}) {
+    return decoded.get(imageRequestKey(url, request))?.failed === true;
+}
+/** A confirmed reconnect may retry a failed bundled request. Keep successful
+ * cached pixels and existing consumers; retire only the remembered failure. */
+export function retryFailedImage(url, request = {}) {
+    const entry = decoded.get(imageRequestKey(url, request));
+    if (entry?.failed)
+        for (const [key, value] of decoded)
+            if (value === entry)
+                decoded.delete(key);
+}
+export function decodedImage(url, request = {}) {
+    const key = imageRequestKey(url, request);
+    const existing = decoded.get(key);
+    if (existing && !existing.failed) {
+        touch(existing);
+        if (request.priority)
+            existing.image.fetchPriority = 'high';
+        return existing.promise;
+    }
+    if (existing) {
+        for (const [key, value] of decoded)
+            if (value === existing)
+                decoded.delete(key);
+    }
+    const image = new globalThis.Image();
+    image.decoding = 'async';
+    if (request.crossOrigin !== undefined)
+        image.crossOrigin = request.crossOrigin;
+    if (request.referrerPolicy)
+        image.referrerPolicy = request.referrerPolicy;
+    image.fetchPriority = request.priority ? 'high' : 'auto';
+    if (request.sizes)
+        image.sizes = request.sizes;
+    if (request.srcSet)
+        image.srcset = request.srcSet;
+    image.src = sourceKey(url);
+    const entry = {
+        image,
+        ready: false,
+        users: 0,
+        bytes: 0,
+        failed: false,
+        promise: image
+            .decode()
+            .then(() => {
+            if (request.srcSet && image.currentSrc) {
+                image.src = image.currentSrc;
+                image.srcset = '';
+            }
+            entry.ready = true;
+            entry.bytes = image.naturalWidth * image.naturalHeight * 4 || 0;
+            // Glass uses the browser-selected URL, so it reuses these exact pixels.
+            decoded.set(imageRequestKey(image.currentSrc || url, {
+                crossOrigin: request.crossOrigin,
+                referrerPolicy: request.referrerPolicy,
+            }), entry);
+            trimDecoded();
+            return image;
+        })
+            .catch(error => {
+            entry.failed = true;
+            trimDecoded();
+            throw error;
+        }),
+    };
+    decoded.set(key, entry);
+    return entry.promise;
+}
+export function retainDecodedImage(url, request = {}) {
+    const ready = decodedImage(url, request);
+    const entry = decoded.get(imageRequestKey(url, request));
+    entry.users++;
+    let released = false;
+    return {
+        ready,
+        release() {
+            if (released)
+                return;
+            released = true;
+            entry.users--;
+            trimDecoded();
+        },
+    };
+}
+/** The element changed source or unmounted before its decode finished: not a failure. */
+export class SupersededImage extends Error {
+    constructor(source) {
+        super(`Image capture superseded: ${source}`);
+    }
+}
+const captures = new WeakMap();
+export const imageCapture = (element) => captures.get(element);
+/** A failed content request contributes no image pixels. Replacement races still
+ * invalidate the measurement; renderer assets must never use this boundary. */
+export async function settleContentImage(ready) {
+    try {
+        return await ready;
+    }
+    catch (error) {
+        if (error instanceof SupersededImage)
+            throw error;
+        return undefined;
+    }
+}
+/** Capture the displayed consumer, including raw img, without a second URL request. */
+export function paintedImage(element) {
+    const capture = imageCapture(element);
+    if (capture)
+        return observedContentImage(capture.ready);
+    if (!element.getAttribute('src') && !element.getAttribute('srcset'))
+        return Promise.resolve(undefined);
+    if (element.complete && element.naturalWidth === 0)
+        return Promise.resolve(undefined);
+    const source = element.currentSrc || element.src;
+    return observedContentImage(element.decode().then(() => {
+        if ((element.currentSrc || element.src) !== source)
+            throw new SupersededImage(source);
+        return element;
+    }));
+}
+/** Measurement stores this promise before rasterization, which may skip a region-owned
+ * node or discard a stale scene. Observe retirement immediately while preserving the
+ * rejection on the original promise so an eventual capture still remeasures. */
+function observedContentImage(ready) {
+    const pixels = settleContentImage(ready);
+    void pixels.catch(() => { });
+    return pixels;
+}
+/** Counts capture registrations and retirements: a kept glass measurement holds the capture it
+ * read (glass/lens/mirrorReuse.ts). */
+let captureRevision = 0;
+export const imageCaptureRevision = () => captureRevision;
+/** Waiters on a retired capture (glass preparation, a push) are released at once, never held
+ * until a decode nobody displays any more settles. */
+export function registerImageCapture(element, capture) {
+    let retire = () => { };
+    const retired = new Promise((_, reject) => {
+        retire = () => reject(new SupersededImage(capture.source));
+    });
+    const registered = { source: capture.source, ready: Promise.race([capture.ready, retired]) };
+    registered.ready.catch(() => { });
+    captures.set(element, registered);
+    captureRevision++;
+    return () => {
+        retire();
+        if (captures.get(element) !== registered)
+            return;
+        captures.delete(element);
+        captureRevision++;
+    };
+}
+/** Target preparation budget for visible bundled artwork. A missed budget is a
+ * performance failure, never permission to reveal an undecoded local Image.
+ * Owner correction: the implementation contract October 10. */
+export const DESTINATION_IMAGE_BUDGET_MS = 100;
+/** Local Images must be ready before reveal. The entering route is translated offscreen,
+ * so visibility is measured in the route's own coordinates. The budget is a checkpoint:
+ * after a miss, keep the source visible and the destination paused until ready or aborted.
+ * AsyncImage's remote placeholder does not register a pending capture. */
+export async function prepareDestinationImages(root, signal, budget = DESTINATION_IMAGE_BUDGET_MS) {
+    const deadline = performance.now() + budget;
+    while (!signal.aborted) {
+        const mounted = prepareMountedContent(root, signal);
+        if (mounted)
+            await mounted;
+        if (signal.aborted)
+            return;
+        const selected = visibleCaptures(root);
+        const remaining = deadline - performance.now();
+        if (!selected.size) {
+            if (hasPendingContent(root))
+                continue;
+            return;
+        }
+        const settled = await new Promise(resolve => {
+            const timer = remaining > 0 ? setTimeout(() => finish(false), remaining) : undefined;
+            function finish(value) {
+                if (timer !== undefined)
+                    clearTimeout(timer);
+                signal.removeEventListener('abort', abort);
+                resolve(value);
+            }
+            const abort = () => finish(false);
+            signal.addEventListener('abort', abort, { once: true });
+            void Promise.allSettled([...selected.values()].map(capture => capture.ready)).then(() => finish(true));
+        });
+        if (signal.aborted)
+            return;
+        if (!settled)
+            continue;
+        // Route content can mount or become visible while another image decodes.
+        // Admit the current destination, including new or replaced requests, rather
+        // than only checking that the original elements still have the same source.
+        const current = [...visibleCaptures(root)].every(([image, capture]) => selected.get(image) === capture);
+        if (current && !hasPendingContent(root))
+            return;
+    }
+}
+/** Synchronous empty admission keeps image-free tab selection immediate. */
+export function hasDestinationImages(root) {
+    return hasPendingContent(root) || visibleCaptures(root).size > 0;
+}
+function visibleCaptures(root) {
+    const selected = new Map();
+    for (const image of root.querySelectorAll('img')) {
+        const capture = captures.get(image);
+        if (capture && imageRequiredForReveal(root, image))
+            selected.set(image, capture);
+    }
+    return selected;
+}
+const viewportSubscribers = new Set();
+const notifyViewport = () => {
+    for (const notify of viewportSubscribers)
+        notify();
+};
+export function subscribeImageViewport(notify) {
+    if (!viewportSubscribers.size)
+        window.addEventListener('resize', notifyViewport);
+    viewportSubscribers.add(notify);
+    return () => {
+        viewportSubscribers.delete(notify);
+        if (!viewportSubscribers.size)
+            window.removeEventListener('resize', notifyViewport);
+    };
+}
+export const imageViewport = () => `${globalThis.innerWidth}:${globalThis.innerHeight}:${globalThis.devicePixelRatio}`;

package/dist/image/vite.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from 'vite';
+/** Explicit image imports remain ordinary Vite assets and enter the shell precache. */
+export declare function imageAssets(): Plugin;

package/dist/image/vite.js

@@ -0,0 +1,63 @@
+import { readFile } from 'node:fs/promises';
+import { basename } from 'node:path';
+import sharp from 'sharp';
+const suffix = '?satin-image';
+/** Explicit image imports remain ordinary Vite assets and enter the shell precache. */
+export function imageAssets() {
+    let development = false;
+    return {
+        name: 'satin:image-assets',
+        enforce: 'pre',
+        configResolved(config) {
+            development = config.command === 'serve';
+        },
+        async resolveId(source, importer) {
+            if (!source.endsWith(suffix))
+                return;
+            const resolved = await this.resolve(source.slice(0, -suffix.length), importer, {
+                skipSelf: true,
+            });
+            if (!resolved || resolved.external)
+                throw Error(`Cannot resolve Satin image: ${source}`);
+            return resolved.id + suffix;
+        },
+        async load(id) {
+            if (!id.endsWith(suffix))
+                return;
+            const path = id.slice(0, -suffix.length);
+            this.addWatchFile(path);
+            const input = await readFile(path);
+            const decoder = sharp(input, { limitInputPixels: 4096 * 4096 });
+            const metadata = await decoder.metadata();
+            if (metadata.pages > 1)
+                throw Error('Satin Image assets must be still images');
+            const image = decoder.rotate();
+            const { info, data } = await image.png().toBuffer({ resolveWithObject: true });
+            const { width, height } = info;
+            // The full-size variant is the original file, so it shows the same pixels as native.
+            // Downscales are resampled anyway: lossy sources get high-quality lossy WebP.
+            const lossless = metadata.format === 'png' || metadata.format === 'gif';
+            const widths = [160, 320, 640, 960, 1280].filter(size => size < width);
+            const variants = await Promise.all([...widths, width].map(async (size) => {
+                const original = size === width;
+                const bytes = original
+                    ? input
+                    : await sharp(data)
+                        .resize({ width: size })
+                        .webp(lossless ? { lossless: true } : { quality: 85 })
+                        .toBuffer();
+                const name = original ? basename(path) : `${basename(path)}-${size}.webp`;
+                const type = original ? `image/${metadata.format}` : 'image/webp';
+                const url = development
+                    ? JSON.stringify(`data:${type};base64,${bytes.toString('base64')}`)
+                    : `import.meta.ROLLUP_FILE_URL_${this.emitFile({ type: 'asset', name, source: bytes })}`;
+                return { width: size, url };
+            }));
+            const placeholder = await sharp(data).resize(1, 1).png().toBuffer();
+            return `const variants = [${variants.map(v => `{width:${v.width},url:${v.url}}`).join(',')}];
+export default {src:variants.at(-1).url,width:${width},height:${height},
+srcSet:variants.map(v => v.url+' '+v.width+'w').join(', '),
+placeholder:${JSON.stringify('data:image/png;base64,' + placeholder.toString('base64'))}};`;
+        },
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,87 @@
+/// <reference path="./image/imports.d.ts" />
+export { useBuildInfo, type BuildInfo } from './app/buildInfo.js';
+export { defineApp, type AppDefinitionInput } from './public/definition.js';
+export { runApp, NavigationStack, NavigationSplitView, TabView, Tab, TabSection, type TabSectionProps, type TabProps, type TabViewProps, useNavigation, type Navigation, type RunAppOptions, type RunAppConfiguration, type NavigationStackProps, type NavigationSplitViewProps, type NavigationArguments, } from './public/runtime.js';
+export { useScenePhase, useAppUpdate, useColorScheme, useHorizontalSizeClass, useVerticalSizeClass, useSafeAreaInsets, useGlassErrors, useSceneStorage, useAppStorage, useNotifications, NotificationPermissionExplainer, type EdgeInsets, type UserInterfaceSizeClass, type ScenePhase, type ColorScheme, type NotificationPermissionExplainerProps, type NotificationAuthorizationStatus, } from './public/environment.js';
+export { useUnsavedChanges } from './root/runtimeContext.js';
+export { preferredColorScheme, type PreferredColorScheme } from './app/appearance.js';
+export { type ActionItem, type SwipeAction, type SwipeActionItem, type SwipeActions, type SwipeActionsConfiguration, type ContextMenuConfiguration, type RowActionsProps, } from './actions/types.js';
+export { type AppIcon, type AppDefinition, type AppCapability, type OrientationFallback, type AppOrientation, type UpdateActivation, } from './app/definition.js';
+export { type ViewportFitPolicy } from './app/viewportValue.js';
+export { type LaunchScreenSlot } from './app/launchScreen.js';
+export { type JustUpdated } from './app/coldLaunchUpdate.js';
+export { defineRoutes, route, param, type Register, type RegisteredRoutes, type RouteProps, type Routes, type RouteDefinition, type Parameter, type ParameterSchema, type RouteParameters, type RouteOptions, } from './public/routes.js';
+export { defineNavigation, type NavigationDeclaration, type StackDeclaration, type RegisteredNavigation, type TabId, type TabDeclaration, } from './public/structure.js';
+export { useScreenLifecycle } from './navigation/navigationContext.js';
+export { type TitleDisplayMode, type Visibility, type NavigationBackButtonBehavior, type ScreenLifecycleCallbacks, type ScreenLifecycle, type TransitionPhase, } from './navigation/types.js';
+export { type RouteParameterValue } from './push/schema.js';
+export { Screen, type ScreenProps } from './public/Screen.js';
+export { DefaultToolbarItem, ToolbarItem, ToolbarItemGroup, ToolbarSpacer, type ToolbarSpacerProps, type DefaultToolbarItemProps, type ToolbarItemProps, } from './public/toolbar.js';
+export { type Searchable, type SearchFieldPlacement, type SearchScopes, type SearchSuggestion, } from './search/searchable.js';
+export { type ToolbarMinimizationBehavior, type ToolbarMinimizationRestoration, type ToolbarMinimizationSafeAreaAdjustment, } from './navigation/toolbarMinimization.js';
+export { Text, VStack, HStack, ZStack, Spacer, Divider, LazyVStack, LazyHStack, LazyVGrid, LazyHGrid, GridItem, type LazyVStackProps, type LazyHStackProps, type LazyVGridProps, type LazyHGridProps, type GridItemValue, type GridItemOptions, type FixedGridItemOptions, type FlexibleGridItemOptions, type AdaptiveGridItemOptions, type TextStyle, type FontWeight, type ContentAlignment, type ContentFrame, type ContentPadding, type ContentProps, type TextProps, type VStackProps, type HStackProps, type ZStackProps, type SpacerProps, } from './content/content.js';
+export { GeometryReader, ViewThatFits, type GeometryReaderProps, type GeometryProxy, type GeometrySize, type GeometryFrame, type ViewThatFitsProps, type ViewThatFitsAxis, } from './content/layout.js';
+export { useScaledMetric } from './content/scaledMetric.js';
+export { Label, type LabelProps } from './public/Label.js';
+export { Selectable, type SelectableProps } from './root/SatinRoot.js';
+export { Zoomable, type ZoomableProps } from './zoom/Zoomable.js';
+export { List, Form, NavigationLink, Button, LabeledContent, ContentUnavailableView, type ContentUnavailableViewProps, RowLabel, Toggle, Picker, Stepper, Slider, TextField, SecureField, TextEditor, EditButton, type ListProps, type ListStyle, type ListSelectionProps, type NavigationLinkProps, type ButtonProps, type ButtonBorderShape, type LabeledContentProps, type RowInteractionProps, type ToggleProps, type PickerProps, type StepperProps, type SliderProps, type TextFieldProps, type HorizontalTextFieldProps, type VerticalTextFieldProps, type TextFieldStyle, type LineLimit, type SecureFieldProps, type TextEditorProps, type FormProps, type RowLabelProps, } from './public/controls.js';
+export { Section, ListRow, RowIcon, type ListRowProps, type RowIconProps, type SectionProps, type Choice, } from './list-form/ListForm.js';
+export { ForEach, useEditMode, type EditMode, type ForEachProps, type ListItemID, } from './list-form/editing.js';
+export { moving, removing } from './list-form/offsets.js';
+export { ProgressView, type ProgressViewProps, type ProgressViewStyle, } from './controls/ProgressView.js';
+export { DatePicker, type DatePickerProps, type DatePickerComponent, type DatePickerRange, type DatePickerStyle, } from './controls/DatePicker.js';
+export { ColorPicker, type ColorPickerProps } from './controls/ColorPicker.js';
+export { useFocusChain, type FocusChainField } from './text-input/focusChain.js';
+export { type TextFieldKind, type SubmitLabel } from './text-input/kinds.js';
+export { Pressable, type PressableProps, type PressableOwnedHandlers } from './press/Pressable.js';
+export { SensoryButton, type SensoryButtonProps, type SensoryFeedback, } from './haptics/SensoryButton.js';
+export { ControlStyleProvider, type ControlStyleValues, type ControlSize, type ButtonRole, type ButtonStyle, type ButtonStyleConfiguration, type BuiltInButtonStyle, type LabelStyle, type LabelStyleConfiguration, type BuiltInLabelStyle, type ToggleStyle, type ToggleStyleConfiguration, type BuiltInToggleStyle, type ControlConfiguration, } from './public/controlStyle.js';
+export { type PressState } from './press/stateMachine.js';
+export { Menu, ContextMenu, type MenuProps, type Action } from './public/actions.js';
+export { FullScreenCover, Sheet, type FullScreenCoverProps, type SheetProps, } from './public/presentation.js';
+export { Alert, ConfirmationDialog, type AlertProps, type ConfirmationDialogProps, type PresentationProps, type AlertTextFieldProps, } from './presentation/Presentation.js';
+export { type PresentationDetent } from './presentation/model.js';
+export { useDismiss } from './presentation/dismiss.js';
+export { ScrollView, type ScrollViewProps, type ScrollViewHandle } from './public/scroll.js';
+export { ScrollTarget } from './scroll/ScrollTarget.js';
+export { type ScrollAnchor, type VerticalScrollGeometry, type ScrollPositionBinding, type ScrollPositionOptions, } from './scroll/position.js';
+export { type ScrollEdge, type ScrollEdgeSelection, type ScrollEdgeEffectStyle, type ScrollEdgeEffectHidden, type ScrollEdgeEffectStyleSelection, } from './scroll/edgePolicy.js';
+export { type ScrollAxis, type ScrollOffset, type ScrollToTopOptions } from './scroll/types.js';
+export { Overlay, type OverlayProps } from './safe-area/Overlay.js';
+export { SafeAreaInset, type SafeAreaInsetProps, type SafeAreaInsetEdge, } from './safe-area/SafeAreaInset.js';
+export { SafeAreaPadding, ContentMargins, SafeAreaBar, IgnoresSafeArea, type SafeAreaPaddingProps, type ContentMarginsProps, type SafeAreaBarProps, type IgnoresSafeAreaProps, type Edge, type EdgeSet, type EdgeLengths, type LayoutModifierProps, type EdgeSetMember, } from './safe-area/modifiers.js';
+export { useKeyboardMetrics, type KeyboardMetrics } from './public/keyboard.js';
+export { type ScrollDismissesKeyboardMode } from './keyboard/adapter.js';
+export { defineNamespace, useNamespace, withAnimation, type NamespaceID, } from './motion/matchedGeometry.js';
+export { Animation, type SpringOptions } from './motion/animationValue.js';
+export { MatchedTransitionSource, NavigationTransition, type MatchedTransitionSourceProps, type ZoomTransitionOptions, } from './public/navigationTransition.js';
+export { Glass } from './public/glassValue.js';
+export { GlassEffect, type GlassEffectProps, type GlassShape } from './public/glass.js';
+export { GlassEffectContainer } from './glass/GlassEffect.js';
+export { type GlassError, type GlassErrorCode } from './glass/errors.js';
+export { type GlassTint } from './glass/regions.js';
+export { type MenuTriggerProps } from './glass/Menu.js';
+export { systemColor, semanticColor, type SystemColorName, type SemanticColorName, } from './public/colors.js';
+export { SymbolImage, SymbolProvider, type SymbolImageProps, type SymbolName, } from './symbols/Symbol.js';
+export { type SymbolGlyph, type SymbolSource, type SymbolWeight, type SymbolScale, type SymbolRenderingMode, } from './symbols/types.js';
+export { Image, AsyncImage, type ImageProps, type AsyncImageProps, type AsyncImagePhase, } from './image/Image.js';
+export { type ImageAsset } from './image/asset.js';
+export { type CoreSymbolName } from './symbols/catalogue.js';
+export { collection, defineDatabase, newId, useQuery, useRecord, Query, type Collection, type CollectionDefinition, type ExportDocument, type TransactionCollection, type WriteFailure, type StringPropertyKey, type CollectionIndexes, type CollectionSchema, type DatabaseMigration, type TransactionCollections, type RecordOfCollection, type CollectionUpdateMethods, type IndexesOfCollection, type DatabaseRecord, } from './data/database.js';
+export { storageQuota } from './public/storage.js';
+export { useTask, type TaskAction, type TaskCommit, type TaskOptions, type TaskRunner, } from './tasks/useTask.js';
+export { useMediaPlayer } from './media/react.js';
+export { type MediaPlayer, type MediaController, type MediaCommandResult, type MediaQueueEntry, type MediaQueueOptions, type MediaSnapshot, type MediaRepeat, } from './media/types.js';
+export { useReachability, type OfflinePresentationProps } from './reachability/react.js';
+export { type ReachabilityState, type ServerReachabilityConfig, type ReachabilityRoutePolicy, type ReachabilityProbeConfig, type ReachabilitySurface, type LocalReachabilityState, type ServerReachabilityState, type ReachabilityPresentation, type ReachabilityStatus, type ReachabilityStateStatus, } from './reachability/model.js';
+export { type KeyboardGeometry } from './keyboard/geometry.js';
+export { cornerClipPath, type CornerShape } from './shapes/corners.js';
+export { Link, useOpenURL, type LinkProps, type OpenURLAction, type OpenURLOptions, type OpenURLResult, } from './web/openURL.js';
+export { WebView, useWebFrame, type WebViewProps, type WebFrameController, type WebFrameState, type WebFrameActionResult, } from './web/WebView.js';
+export { defineWebAuthentication, type WebAuthentication, type WebAuthenticationConfiguration, type WebAuthenticationExchange, type WebAuthenticationState, type WebAuthenticationRequest, type WebAuthenticationStartResult, type WebAuthenticationCallbackResult, } from './web/authentication.js';
+export { useWebAuthentication } from './web/useWebAuthentication.js';
+export { PhotosPicker, FileImporter } from './public/filePickers.js';
+export type { PhotosPickerProps, FileImporterProps } from './public/filePickers.js';
+export { ShareLink, PasteButton } from './public/deviceActions.js';
+export type { ShareLinkProps, PasteButtonProps } from './public/deviceActions.js';

package/dist/index.js

@@ -0,0 +1,102 @@
+// The public satin API, grouped as an app uses it.
+// the implementation contract governs every export.
+// App and runtime
+export { useBuildInfo } from './app/buildInfo.js';
+export { defineApp } from './public/definition.js';
+export { runApp, NavigationStack, NavigationSplitView, TabView, Tab, TabSection, useNavigation, } from './public/runtime.js';
+export { useScenePhase, useAppUpdate, useColorScheme, useHorizontalSizeClass, useVerticalSizeClass, useSafeAreaInsets, useGlassErrors, useSceneStorage, useAppStorage, useNotifications, NotificationPermissionExplainer, } from './public/environment.js';
+export { useUnsavedChanges } from './root/runtimeContext.js';
+export { preferredColorScheme } from './app/appearance.js';
+export {} from './actions/types.js';
+export {} from './app/definition.js';
+export {} from './app/viewportValue.js';
+export {} from './app/launchScreen.js';
+export {} from './app/coldLaunchUpdate.js';
+// Routes and navigation
+export { defineRoutes, route, param, } from './public/routes.js';
+export { defineNavigation, } from './public/structure.js';
+export { useScreenLifecycle } from './navigation/navigationContext.js';
+export {} from './navigation/types.js';
+export {} from './push/schema.js';
+// Screen chrome and toolbars
+export { Screen } from './public/Screen.js';
+export { DefaultToolbarItem, ToolbarItem, ToolbarItemGroup, ToolbarSpacer, } from './public/toolbar.js';
+export {} from './search/searchable.js';
+export {} from './navigation/toolbarMinimization.js';
+// Content: text, stacks and grids
+export { Text, VStack, HStack, ZStack, Spacer, Divider, LazyVStack, LazyHStack, LazyVGrid, LazyHGrid, GridItem, } from './content/content.js';
+export { GeometryReader, ViewThatFits, } from './content/layout.js';
+export { useScaledMetric } from './content/scaledMetric.js';
+export { Label } from './public/Label.js';
+export { Selectable } from './root/SatinRoot.js';
+export { Zoomable } from './zoom/Zoomable.js';
+// Lists, forms and controls
+export { List, Form, NavigationLink, Button, LabeledContent, ContentUnavailableView, RowLabel, Toggle, Picker, Stepper, Slider, TextField, SecureField, TextEditor, EditButton, } from './public/controls.js';
+export { Section, ListRow, RowIcon, } from './list-form/ListForm.js';
+export { ForEach, useEditMode, } from './list-form/editing.js';
+export { moving, removing } from './list-form/offsets.js';
+export { ProgressView, } from './controls/ProgressView.js';
+export { DatePicker, } from './controls/DatePicker.js';
+export { ColorPicker } from './controls/ColorPicker.js';
+export { useFocusChain } from './text-input/focusChain.js';
+export {} from './text-input/kinds.js';
+export { Pressable } from './press/Pressable.js';
+export { SensoryButton, } from './haptics/SensoryButton.js';
+export { ControlStyleProvider, } from './public/controlStyle.js';
+export {} from './press/stateMachine.js';
+// Menus and actions
+export { Menu, ContextMenu } from './public/actions.js';
+// Presentations
+export { FullScreenCover, Sheet, } from './public/presentation.js';
+export { Alert, ConfirmationDialog, } from './presentation/Presentation.js';
+export {} from './presentation/model.js';
+export { useDismiss } from './presentation/dismiss.js';
+// Scrolling
+export { ScrollView } from './public/scroll.js';
+export { ScrollTarget } from './scroll/ScrollTarget.js';
+export {} from './scroll/position.js';
+export {} from './scroll/edgePolicy.js';
+export {} from './scroll/types.js';
+// Safe area and layout modifiers
+export { Overlay } from './safe-area/Overlay.js';
+export { SafeAreaInset, } from './safe-area/SafeAreaInset.js';
+export { SafeAreaPadding, ContentMargins, SafeAreaBar, IgnoresSafeArea, } from './safe-area/modifiers.js';
+export { useKeyboardMetrics } from './public/keyboard.js';
+export {} from './keyboard/adapter.js';
+// Animation
+export { defineNamespace, useNamespace, withAnimation, } from './motion/matchedGeometry.js';
+export { Animation } from './motion/animationValue.js';
+export { MatchedTransitionSource, NavigationTransition, } from './public/navigationTransition.js';
+// Glass
+export { Glass } from './public/glassValue.js';
+export { GlassEffect } from './public/glass.js';
+export { GlassEffectContainer } from './glass/GlassEffect.js';
+export {} from './glass/errors.js';
+export {} from './glass/regions.js';
+export {} from './glass/Menu.js';
+// Colours, symbols and images
+export { systemColor, semanticColor, } from './public/colors.js';
+export { SymbolImage, SymbolProvider, } from './symbols/Symbol.js';
+export {} from './symbols/types.js';
+export { Image, AsyncImage, } from './image/Image.js';
+export {} from './image/asset.js';
+export {} from './symbols/catalogue.js';
+// Data and storage
+export { collection, defineDatabase, newId, useQuery, useRecord, Query, } from './data/database.js';
+export { storageQuota } from './public/storage.js';
+// Tasks, media and connectivity
+export { useTask, } from './tasks/useTask.js';
+export { useMediaPlayer } from './media/react.js';
+export {} from './media/types.js';
+export { useReachability } from './reachability/react.js';
+export {} from './reachability/model.js';
+export {} from './keyboard/geometry.js';
+// App shape geometry
+export { cornerClipPath } from './shapes/corners.js';
+// Web pages and authentication handoff
+export { Link, useOpenURL, } from './web/openURL.js';
+export { WebView, useWebFrame, } from './web/WebView.js';
+export { defineWebAuthentication, } from './web/authentication.js';
+export { useWebAuthentication } from './web/useWebAuthentication.js';
+export { PhotosPicker, FileImporter } from './public/filePickers.js';
+export { ShareLink, PasteButton } from './public/deviceActions.js';

package/dist/install.d.ts

@@ -0,0 +1,8 @@
+/**
+ * `@satinhq/kit/install`: building blocks for a custom install page, set with
+ * `satinApp(app, { installPage: './src/Install.js' })`. Satin wraps that page: its head,
+ * the platform gate and the deployment check run first, and the page only loads when the
+ * deployment is sound. These read the page Satin built; they throw anywhere else.
+ */
+export { copyInstallLink, readInstallContext, type CopyLinkResult, type InstallApp, type InstallBrowser, type InstallContext, type InstallDevice, } from './app/installContext.js';
+export { InstallSteps, InstallTip, useInstallContext } from './app/InstallComponents.js';

package/dist/install.js

@@ -0,0 +1,8 @@
+/**
+ * `@satinhq/kit/install`: building blocks for a custom install page, set with
+ * `satinApp(app, { installPage: './src/Install.tsx' })`. Satin wraps that page: its head,
+ * the platform gate and the deployment check run first, and the page only loads when the
+ * deployment is sound. These read the page Satin built; they throw anywhere else.
+ */
+export { copyInstallLink, readInstallContext, } from './app/installContext.js';
+export { InstallSteps, InstallTip, useInstallContext } from './app/InstallComponents.js';