@symbiote-native/svelte 0.1.0

package/build/components/image-background/index.svelte

@@ -0,0 +1,81 @@
+<script lang="ts" module>
+  // ImageBackground: render-only composition (absolute-fill Image behind, children on top).
+  // Calls renderImageBackground() straight from core/components for the absolute-fill
+  // positioning + wrapper-dimension proxy onto the inner Image — both tags stay literal (the
+  // wrapper hosts `{@render children?.()}` as a live sibling after the image, which the
+  // generic descriptorToSvelte bridge can't safely own: appending the image inside an $effect
+  // would race Svelte's own placement of the live children and could reorder them — see
+  // svelte-adapter-dom-shim skill §19), so `.props`/`.children[0].props` are destructured onto
+  // the two known host tags, same pattern as Modal/index.svelte.
+  import type { IImageBackgroundProps } from './image-background-props';
+
+  export type { IImageBackgroundProps };
+</script>
+
+<script lang="ts">
+  import { renderImageBackground, resolveAccessibilityProps } from '@symbiote-native/components';
+  import { resolveClassName } from '@symbiote-native/engine';
+  import { createAttachmentsSync } from '../../runes/attachments';
+  import type { ShimElement } from '../../dom-shim';
+
+  let {
+    children,
+    style,
+    imageStyle,
+    class: className,
+    source,
+    defaultSource,
+    loadingIndicatorSource,
+    resizeMode,
+    tintColor,
+    src,
+    srcSet,
+    alt,
+    width,
+    height,
+    crossOrigin,
+    referrerPolicy,
+    ...passthrough
+  }: IImageBackgroundProps = $props();
+
+  const resolvedImageStyle = $derived(
+    typeof imageStyle === 'string' ? resolveClassName(imageStyle) : imageStyle,
+  );
+
+  const descriptor = $derived(
+    renderImageBackground({
+      style,
+      imageStyle: resolvedImageStyle,
+      image: {
+        source,
+        defaultSource,
+        loadingIndicatorSource,
+        resizeMode,
+        tintColor,
+        src,
+        srcSet,
+        alt,
+        width,
+        height,
+        crossOrigin,
+        referrerPolicy,
+        passthrough: resolveAccessibilityProps(passthrough),
+      },
+    }),
+  );
+  const imageBag = $derived.by(() => {
+    const child = descriptor.children[0];
+    return typeof child === 'string' ? {} : child.props;
+  });
+  const wrapperBag = $derived({ ...descriptor.props, class: className });
+
+  // See View.svelte's note on `{@attach}` — the attachment binds to the OUTER wrapper, the node
+  // this component's own `class`/`style` land on and the one a caller means by "this component".
+  let hostShim = $state.raw<ShimElement | null>(null);
+  const syncAttachments = createAttachmentsSync();
+  $effect(() => {
+    syncAttachments(hostShim, passthrough);
+  });
+</script>
+
+<symbiote-view p={wrapperBag} bind:this={hostShim}><symbiote-image p={imageBag} />{@render children?.()}</symbiote-view>

package/build/components/image-background/index.svelte.d.ts

@@ -0,0 +1,5 @@
+import type { IImageBackgroundProps } from './image-background-props';
+export type { IImageBackgroundProps };
+declare const Index: import("svelte").Component<IImageBackgroundProps, {}, "">;
+type Index = ReturnType<typeof Index>;
+export default Index;

package/build/components/index.d.ts

@@ -0,0 +1,50 @@
+export { default as View } from './View.svelte';
+export { default as Text } from './Text.svelte';
+export type { IViewProps } from './view-props';
+export type { ITextProps } from './text-props';
+export { default as ActivityIndicator } from './activity-indicator/index.svelte';
+export type { IActivityIndicatorProps } from './activity-indicator/activity-indicator-props';
+export { Image } from './image';
+export type { IImageProps, IImageStatics } from './image';
+export { default as ImageBackground } from './image-background/index.svelte';
+export type { IImageBackgroundProps } from './image-background/image-background-props';
+export { default as InputAccessoryView } from './input-accessory-view/index.svelte';
+export type { IInputAccessoryViewProps } from './input-accessory-view/input-accessory-view-props';
+export { default as KeyboardAvoidingView } from './keyboard-avoiding-view/index.svelte';
+export type { IKeyboardAvoidingViewProps, IKeyboardAvoidingBehavior, } from './keyboard-avoiding-view/keyboard-avoiding-view-props';
+export { default as Switch } from './switch/index.svelte';
+export type { ISwitchProps } from './switch/switch-props';
+export { default as TextInput } from './text-input/index.svelte';
+export type { ITextInputProps } from './text-input/text-input-props';
+export type { ITextInputHandle } from '@symbiote-native/components';
+export { default as Modal } from './modal/index.svelte';
+export type { IModalProps } from './modal/modal-props';
+export { default as SafeAreaView } from './SafeAreaView.svelte';
+export type { ISafeAreaViewProps } from './safe-area-view-props';
+export { default as RefreshControl } from './RefreshControl.svelte';
+export type { IRefreshControlProps } from './refresh-control-props';
+export { default as Pressable } from './pressable/index.svelte';
+export type { IPressableProps } from './pressable/pressable-props';
+export { default as TouchableOpacity } from './touchable-opacity/index.svelte';
+export type { ITouchableOpacityProps } from './touchable-opacity/touchable-opacity-props';
+export { default as TouchableHighlight } from './touchable-highlight/index.svelte';
+export type { ITouchableHighlightProps } from './touchable-highlight/touchable-highlight-props';
+export { default as TouchableWithoutFeedback } from './touchable-without-feedback/index.svelte';
+export type { ITouchableWithoutFeedbackProps } from './touchable-without-feedback/touchable-without-feedback-props';
+export { TouchableNativeFeedback } from './touchable-native-feedback';
+export type { ITouchableNativeFeedbackProps } from './touchable-native-feedback';
+export { default as Button } from './button.svelte';
+export type { IButtonProps } from './button-props';
+export { default as ScrollView } from './scroll-view/index.svelte';
+export type { IScrollViewProps } from './scroll-view/scroll-view-props';
+export type { IScrollViewHandle } from '@symbiote-native/components';
+export { default as ScrollViewStickyHeader } from './scroll-view/sticky-header.svelte';
+export type { IStickyHeaderComponentProps } from './scroll-view/sticky-header-props';
+export { default as VirtualizedList } from './virtualized-list/index.svelte';
+export type { IVirtualizedListProps, IVirtualizedListHandle, } from './virtualized-list/virtualized-list-props';
+export { default as FlatList } from './flat-list/index.svelte';
+export type { IFlatListProps, IFlatListHandle } from './flat-list/flat-list-props';
+export { default as VirtualizedSectionList } from './virtualized-section-list/index.svelte';
+export type { IVirtualizedSectionListProps } from './virtualized-section-list/virtualized-section-list-props';
+export { default as SectionList } from './section-list/index.svelte';
+export type { ISectionListProps, ISection } from './section-list/section-list-props';

package/build/components/index.js

@@ -0,0 +1,24 @@
+export { default as View } from './View.svelte';
+export { default as Text } from './Text.svelte';
+export { default as ActivityIndicator } from './activity-indicator/index.svelte';
+export { Image } from './image/index.js';
+export { default as ImageBackground } from './image-background/index.svelte';
+export { default as InputAccessoryView } from './input-accessory-view/index.svelte';
+export { default as KeyboardAvoidingView } from './keyboard-avoiding-view/index.svelte';
+export { default as Switch } from './switch/index.svelte';
+export { default as TextInput } from './text-input/index.svelte';
+export { default as Modal } from './modal/index.svelte';
+export { default as SafeAreaView } from './SafeAreaView.svelte';
+export { default as RefreshControl } from './RefreshControl.svelte';
+export { default as Pressable } from './pressable/index.svelte';
+export { default as TouchableOpacity } from './touchable-opacity/index.svelte';
+export { default as TouchableHighlight } from './touchable-highlight/index.svelte';
+export { default as TouchableWithoutFeedback } from './touchable-without-feedback/index.svelte';
+export { TouchableNativeFeedback } from './touchable-native-feedback/index.js';
+export { default as Button } from './button.svelte';
+export { default as ScrollView } from './scroll-view/index.svelte';
+export { default as ScrollViewStickyHeader } from './scroll-view/sticky-header.svelte';
+export { default as VirtualizedList } from './virtualized-list/index.svelte';
+export { default as FlatList } from './flat-list/index.svelte';
+export { default as VirtualizedSectionList } from './virtualized-section-list/index.svelte';
+export { default as SectionList } from './section-list/index.svelte';

package/build/components/input-accessory-view/index.svelte

@@ -0,0 +1,48 @@
+<script lang="ts" module>
+  // InputAccessoryView: render-only host assembly (iOS). Calls the shared
+  // core/components/src/view/render-input-accessory-view.ts's renderInputAccessoryView()
+  // directly (nativeID/backgroundColor/style -> the host node, everything else passthrough) —
+  // the same calling convention as keyboard-avoiding-view/index.svelte's shared-render-fn call,
+  // rather than hand-duplicating its prop-assembly logic (per the svelte-adapter-dom-shim
+  // skill's §15/§19 correction: a fixed-shape Descriptor still has to be CALLED, not
+  // re-derived). The root tag stays literal below since renderInputAccessoryView always paints
+  // the same 'symbiote-input-accessory-view' host — no dynamic <svelte:element> needed. The
+  // host has no structural children of its own; the user's children nest directly under it.
+  import type { IInputAccessoryViewProps } from './input-accessory-view-props';
+
+  export type { IInputAccessoryViewProps };
+</script>
+
+<script lang="ts">
+  import { renderInputAccessoryView, resolveAccessibilityProps } from '@symbiote-native/components';
+  import { createAttachmentsSync } from '../../runes/attachments';
+  import type { ShimElement } from '../../dom-shim';
+
+  let {
+    nativeID,
+    backgroundColor,
+    style,
+    children,
+    ...passthrough
+  }: IInputAccessoryViewProps = $props();
+
+  const descriptor = $derived(
+    renderInputAccessoryView({
+      nativeID,
+      backgroundColor,
+      style,
+      passthrough: resolveAccessibilityProps(passthrough),
+    }),
+  );
+
+  // See View.svelte's note on `{@attach}`.
+  let hostShim = $state.raw<ShimElement | null>(null);
+  const syncAttachments = createAttachmentsSync();
+  $effect(() => {
+    syncAttachments(hostShim, passthrough);
+  });
+</script>
+
+<symbiote-input-accessory-view p={descriptor.props} bind:this={hostShim}>
+  {@render children?.()}
+</symbiote-input-accessory-view>

package/build/components/input-accessory-view/index.svelte.d.ts

@@ -0,0 +1,5 @@
+import type { IInputAccessoryViewProps } from './input-accessory-view-props';
+export type { IInputAccessoryViewProps };
+declare const Index: import("svelte").Component<IInputAccessoryViewProps, {}, "">;
+type Index = ReturnType<typeof Index>;
+export default Index;

package/build/components/input-accessory-view/input-accessory-view-props.d.ts

@@ -0,0 +1,11 @@
+import type { Snippet } from 'svelte';
+import type { IStyleProp, IViewStyle } from '@symbiote-native/engine';
+import type { IAccessibilityProps, IAriaProps } from '@symbiote-native/components';
+import type { ISvelteClassValue } from '../../class-value';
+export interface IInputAccessoryViewProps extends IAccessibilityProps, IAriaProps {
+    nativeID?: string;
+    backgroundColor?: string;
+    style?: IStyleProp<IViewStyle>;
+    class?: ISvelteClassValue;
+    children?: Snippet;
+}

package/build/components/input-accessory-view/input-accessory-view-props.js

@@ -0,0 +1 @@
+export {};

package/build/components/keyboard-avoiding-view/index.svelte

@@ -0,0 +1,135 @@
+<script lang="ts" module>
+  // KeyboardAvoidingView: composes a wrapper View and shifts it as the keyboard shows/hides. The
+  // inset math + the behavior -> style/structure decision live framework-agnostic in
+  // @symbiote-native/components (render-keyboard-avoiding-view, shared verbatim with React/Vue);
+  // this adapter supplies only the lifecycle: $state for the inset, a mutable frame/initialHeight
+  // pair (NOT $state — changing them alone shouldn't re-render, same non-reactive-ref shape as
+  // React's frameRef/initialHeightRef and Vue's plain `let frame`), an $effect subscribing to the
+  // Keyboard module (mirrors React's useEffect / Vue's onMounted+onUnmounted pair), and the
+  // wrapper assembly around the Snippet children.
+  //
+  // render-keyboard-avoiding-view.ts does NOT return a Descriptor here (by its own design — it
+  // returns a layout DESCRIPTION instead, because KAV wraps arbitrary user children the Descriptor
+  // model can't carry), so there is no Descriptor-consumption question for this component at all;
+  // the two structural shapes ('nested' vs 'wrapper') are written directly as the two markup
+  // branches below.
+  import type { IKeyboardAvoidingViewProps } from './keyboard-avoiding-view-props';
+
+  export type { IKeyboardAvoidingViewProps };
+</script>
+
+<script lang="ts">
+  import {
+    Keyboard,
+    KEYBOARD_EVENT,
+    dlog,
+    type IEventSubscription,
+    type ISymbioteEvent,
+  } from '@symbiote-native/engine';
+  import { createAttachmentsSync } from '../../runes/attachments';
+  import type { ShimElement } from '../../dom-shim';
+  import {
+    computeInset,
+    readKeyboardFrame,
+    readLayoutFrame,
+    resolveKeyboardAvoidingLayout,
+    resolveAccessibilityProps,
+    DEFAULT_VERTICAL_OFFSET,
+    type IMeasuredFrame,
+  } from '@symbiote-native/components';
+
+  let {
+    behavior,
+    enabled = true,
+    keyboardVerticalOffset = DEFAULT_VERTICAL_OFFSET,
+    contentContainerStyle,
+    style,
+    children,
+    onLayout,
+    class: className,
+    ...passthrough
+  }: IKeyboardAvoidingViewProps = $props();
+
+  let inset = $state(0);
+  // Mutable, not $state: changing the measured frame alone shouldn't re-render; it only feeds the
+  // next keyboard event's inset math.
+  let frame: IMeasuredFrame | undefined;
+  let initialHeight: number | undefined;
+
+  function onShow(payload: unknown): void {
+    const keyboard = readKeyboardFrame(payload);
+    const next = computeInset(frame, keyboard, keyboardVerticalOffset);
+    dlog(`KeyboardAvoidingView show -> inset ${next}`);
+    inset = next;
+  }
+  function onHide(): void {
+    dlog('KeyboardAvoidingView hide -> inset 0');
+    inset = 0;
+  }
+
+  // No reactive state is read synchronously in this callback body (only inside onShow/onHide,
+  // which run later at event-time via closures over the live `keyboardVerticalOffset` prop), so
+  // this effect has zero tracked dependencies and runs exactly once per mount/unmount — the same
+  // subscribe-once/cleanup-once shape as Vue's onMounted+onUnmounted pair.
+  $effect(() => {
+    const subscriptions: IEventSubscription[] = [
+      Keyboard.addListener(KEYBOARD_EVENT.didShow, onShow),
+      Keyboard.addListener(KEYBOARD_EVENT.didChangeFrame, onShow),
+      Keyboard.addListener(KEYBOARD_EVENT.didHide, onHide),
+    ];
+    return () => {
+      for (const subscription of subscriptions) subscription.remove();
+    };
+  });
+
+  function handleLayout(event: ISymbioteEvent): void {
+    const measured = readLayoutFrame(event.nativeEvent.layout);
+    if (measured !== undefined) {
+      frame = measured;
+      if (initialHeight === undefined) initialHeight = measured.height;
+    }
+    onLayout?.(event);
+  }
+
+  // When disabled the inset is forced to 0, so every behavior mode renders the view untouched.
+  const effectiveInset = $derived(enabled ? inset : 0);
+
+  const layout = $derived(
+    resolveKeyboardAvoidingLayout({
+      behavior,
+      effectiveInset,
+      initialHeight,
+      style,
+      contentContainerStyle,
+    }),
+  );
+
+  const wrapperBag = $derived({
+    ...resolveAccessibilityProps(passthrough),
+    style: layout.wrapperStyle,
+    class: className,
+    onLayout: handleLayout,
+  });
+
+  const innerBag = $derived(layout.kind === 'nested' ? { style: layout.innerStyle } : undefined);
+
+  // See View.svelte's note on `{@attach}` — bound to the OUTER wrapper, which is the node
+  // this component's own style lands on in both the nested and flat layouts.
+  let hostShim = $state.raw<ShimElement | null>(null);
+  const syncAttachments = createAttachmentsSync();
+  $effect(() => {
+    syncAttachments(hostShim, passthrough);
+  });
+</script>
+
+{#if layout.kind === 'nested'}
+  <symbiote-view p={wrapperBag} bind:this={hostShim}>
+    <symbiote-view p={innerBag}>
+      {@render children?.()}
+    </symbiote-view>
+  </symbiote-view>
+{:else}
+  <symbiote-view p={wrapperBag} bind:this={hostShim}>
+    {@render children?.()}
+  </symbiote-view>
+{/if}

package/build/components/keyboard-avoiding-view/index.svelte.d.ts

@@ -0,0 +1,5 @@
+import type { IKeyboardAvoidingViewProps } from './keyboard-avoiding-view-props';
+export type { IKeyboardAvoidingViewProps };
+declare const Index: import("svelte").Component<IKeyboardAvoidingViewProps, {}, "">;
+type Index = ReturnType<typeof Index>;
+export default Index;

package/build/components/keyboard-avoiding-view/keyboard-avoiding-view-props.d.ts

@@ -0,0 +1,15 @@
+import type { Snippet } from 'svelte';
+import type { ISymbioteEvent, IStyleProp, IViewStyle } from '@symbiote-native/engine';
+import type { IAccessibilityProps, IAriaProps, IKeyboardAvoidingBehavior } from '@symbiote-native/components';
+import type { ISvelteClassValue } from '../../class-value';
+export type { IKeyboardAvoidingBehavior } from '@symbiote-native/components';
+export interface IKeyboardAvoidingViewProps extends IAccessibilityProps, IAriaProps {
+    behavior?: IKeyboardAvoidingBehavior;
+    enabled?: boolean;
+    keyboardVerticalOffset?: number;
+    contentContainerStyle?: IStyleProp<IViewStyle>;
+    style?: IStyleProp<IViewStyle>;
+    class?: ISvelteClassValue;
+    children?: Snippet;
+    onLayout?: (event: ISymbioteEvent) => void;
+}

package/build/components/keyboard-avoiding-view/keyboard-avoiding-view-props.js

@@ -0,0 +1 @@
+export {};

package/build/components/modal/index.svelte

@@ -0,0 +1,126 @@
+<script lang="ts" module>
+  // Modal: the Svelte lifecycle half. RCTModalHostView is an ordinary Fabric host node
+  // committing through the SAME childSet as the rest of the tree (no second JS surface). The
+  // style math (backdrop override, container/host styles, presentationStyle default), the
+  // visible gate, and the iOS keep-alive reducer all live framework-agnostic in
+  // @symbiote-native/components and are shared verbatim with React/Vue (core/components/src/
+  // state/modal.ts + view/render-modal.ts); Svelte supplies only the lifecycle:
+  //   - $state over the keep-alive reducer (switchReducer's twin: modalReducer)
+  //   - a POST-render $effect driving the visible->hidden transition (Svelte's $effect runs
+  //     after the DOM update, the same "one keep-alive frame survives" timing as React's
+  //     useEffect / Vue's flush:'post' watch)
+  //   - the descriptor bridge: renderModal() always paints the SAME fixed shape (one
+  //     symbiote-modal host wrapping one symbiote-view container — only prop VALUES vary,
+  //     never structure, per svelte-adapter-dom-shim skill §15), so rather than building a
+  //     generic Descriptor->Svelte walker (there is none, and none is needed) this hand-authors
+  //     the two literal host tags and reads renderModal()'s computed props off the fixed
+  //     `root.props` / `root.children[0].props` positions, exactly like React's createElement
+  //     chain and Vue's h() chain do.
+  import type { IModalProps } from './modal-props';
+
+  export type { IModalProps };
+</script>
+
+<script lang="ts">
+  import {
+    createInitialModalState,
+    modalReducer,
+    renderModal,
+    resolveAccessibilityProps,
+    shouldRenderModal,
+  } from '@symbiote-native/components';
+  import { dlog } from '@symbiote-native/engine';
+  import { createAttachmentsSync } from '../../runes/attachments';
+  import type { ShimElement } from '../../dom-shim';
+
+  let rawProps: IModalProps = $props();
+
+  let state = $state(createInitialModalState(rawProps.visible === true));
+
+  const resolved = $derived(resolveAccessibilityProps(rawProps));
+  const isVisible = $derived(resolved.visible === true);
+  const shouldRender = $derived(shouldRenderModal(isVisible, state));
+
+  // POST-render, mirroring state/modal.ts's contract: fires after the DOM update following the
+  // render that used the OLD state, so a visible->hidden transition keeps the node mounted one
+  // more frame (state.isRendered still true) before the NEXT render drops it. The reducer is
+  // identity-stable, so a no-op transition — including this effect's own first run on mount —
+  // triggers no extra render.
+  //
+  // Under this adapter's microtask-coalesced requestCommit() (element.ts's `p` setter), Svelte
+  // settles the whole visible->hidden cascade within the SAME microtask flush that processes the
+  // triggering prop change, so the keep-alive frame genuinely happens (a render sees
+  // isVisible=false with isRendered still true before this effect flips it) but isn't observable
+  // as its own committed Fabric frame the way React's per-render synchronous commit makes it.
+  $effect(() => {
+    state = modalReducer(state, isVisible ? { type: 'show' } : { type: 'hide' });
+  });
+
+  $effect(() => {
+    if (!shouldRender) dlog('Modal hidden -> no node committed');
+  });
+
+  // Owns its host element (symbiote-modal), so it folds aria/role via `resolved` above; the
+  // resolved fields ride the host node via `...passthrough` — includes onShow/onDismiss/
+  // onRequestClose/onOrientationChange (real ViewConfig DirectEvents) and every accessibility*
+  // field, untouched, exactly like React's `...passthrough`.
+  const root = $derived.by(() => {
+    const {
+      visible,
+      transparent,
+      backdropColor,
+      animationType,
+      presentationStyle,
+      supportedOrientations,
+      hardwareAccelerated,
+      statusBarTranslucent,
+      navigationBarTranslucent,
+      allowSwipeDismissal,
+      style,
+      class: className,
+      children: _children,
+      ...passthrough
+    } = resolved;
+
+    const descriptor = renderModal({
+      visible,
+      transparent,
+      backdropColor,
+      animationType,
+      presentationStyle,
+      supportedOrientations,
+      hardwareAccelerated,
+      statusBarTranslucent,
+      navigationBarTranslucent,
+      allowSwipeDismissal,
+      style,
+      passthrough,
+    });
+
+    // root = symbiote-modal > [container]; the children snippet nests UNDER the container View,
+    // never as a direct sibling of the host (RN's modal content layout) — see render-modal.ts.
+    const [container] = descriptor.children;
+    const containerProps = typeof container === 'string' ? {} : container.props;
+
+    return {
+      hostBag: descriptor.props,
+      containerBag: { ...containerProps, class: className },
+    };
+  });
+
+  // See View.svelte's note on `{@attach}` — bound to the modal host itself, the node this
+  // component owns (the inner container view is Modal's own structural child).
+  let hostShim = $state.raw<ShimElement | null>(null);
+  const syncAttachments = createAttachmentsSync();
+  $effect(() => {
+    syncAttachments(hostShim, rawProps);
+  });
+</script>
+
+{#if shouldRender}
+  <symbiote-modal p={root.hostBag} bind:this={hostShim}>
+    <symbiote-view p={root.containerBag}>
+      {@render rawProps.children?.()}
+    </symbiote-view>
+  </symbiote-modal>
+{/if}

package/build/components/modal/index.svelte.d.ts

@@ -0,0 +1,5 @@
+import type { IModalProps } from './modal-props';
+export type { IModalProps };
+declare const Index: import("svelte").Component<IModalProps, {}, "">;
+type Index = ReturnType<typeof Index>;
+export default Index;

package/build/components/modal/modal-props.d.ts

@@ -0,0 +1,24 @@
+import type { Snippet } from 'svelte';
+import type { IStyleProp, ISymbioteEvent, IViewStyle } from '@symbiote-native/engine';
+import type { IAccessibilityProps, IAriaProps, IModalAnimationType, IModalOrientation, IModalPresentationStyle } from '@symbiote-native/components';
+import type { ISvelteClassValue } from '../../class-value';
+export type { IModalAnimationType, IModalOrientation, IModalOrientationChangeEvent, IModalPresentationStyle, } from '@symbiote-native/components';
+export interface IModalProps extends IAccessibilityProps, IAriaProps {
+    visible?: boolean;
+    transparent?: boolean;
+    backdropColor?: string;
+    animationType?: IModalAnimationType;
+    presentationStyle?: IModalPresentationStyle;
+    supportedOrientations?: ReadonlyArray<IModalOrientation>;
+    hardwareAccelerated?: boolean;
+    statusBarTranslucent?: boolean;
+    navigationBarTranslucent?: boolean;
+    allowSwipeDismissal?: boolean;
+    onShow?: () => void;
+    onDismiss?: () => void;
+    onRequestClose?: () => void;
+    onOrientationChange?: (event: ISymbioteEvent) => void;
+    style?: IStyleProp<IViewStyle>;
+    class?: ISvelteClassValue;
+    children?: Snippet;
+}

package/build/components/modal/modal-props.js

@@ -0,0 +1 @@
+export {};