@symbiote-native/svelte 1.0.0 → 3.0.0

package/build/components/text-input/index.svelte

@@ -1,372 +0,0 @@
-<script lang="ts" module>
-  // TextInput: the controlled-value / event-count handshake, calling straight into
-  // core/components/src/view/render-text-input.ts's renderTextInput() for the prop assembly —
-  // its returned Descriptor's `.props` is destructured onto whichever of the two literal host
-  // tags `isMultiline` picks below. NOT `<svelte:element this={descriptor.type}>`: a dynamic tag
-  // compiles through Svelte's generic setAttribute path, not the custom-element `p=` property-set
-  // codegen every symbiote-* tag needs (proven by a real regression — see svelte-adapter-dom-shim
-  // skill §15). Reuses the shared logic verbatim (resolveTextInputProps / foldText /
-  // textFromChange / eventCountFromChange / shouldCommandText). Runes: `$state.raw` holds the
-  // shim-element/engine-node reference (imperative commands read the RAW ShimElement — see
-  // switch/index.svelte's header comment for why `$state()` would break the engine's
-  // WeakMap-keyed identity lookup), `$state` tracks the acknowledged event count, and `$effect`
-  // drives the controlled-write command — the TextInput twin of Switch's snap-back effect. The
-  // imperative handle (focus/blur/clear/isFocused/setSelection) is exposed the Svelte 5 way:
-  // plain functions declared in the INSTANCE script (not here in `<script module>`, shared
-  // across every instance) become callable off a parent's `bind:this` target.
-  //
-  // `value` is `$bindable()`: `<TextInput bind:value={x}>` round-trips a native edit into `x`
-  // with no adapter-side translation beyond the one-line echo in handleChange, GATED on
-  // `onValueChange` being absent. Ungated, it would defeat the controlled-write correction below
-  // for every plain `value`+`onValueChange` consumer too, not just bind: ones: a `$bindable`
-  // prop with no `bind:` caller still caches the child's own write as a local override (verified
-  // against svelte's real `prop()` runtime, `reactivity/props.js`), so an unconditional echo
-  // would make `value` agree with `lastNativeText` on every native report and silently
-  // short-circuit `shouldCommandText` — even for a parent that never once accepts.
-  import type { ITextInputProps } from './text-input-props';
-
-  export type { ITextInputProps };
-  export type { ITextInputHandle } from '@symbiote-native/components';
-</script>
-
-<script lang="ts">
-  import {
-    resolveAccessibilityProps,
-    resolveTextInputProps,
-    renderTextInput,
-    foldText,
-    textFromChange,
-    eventCountFromChange,
-    shouldCommandText,
-    INITIAL_EVENT_COUNT,
-    SELECTION_NONE,
-  } from '@symbiote-native/components';
-  import {
-    dispatchViewCommand,
-    dlog,
-    blurTextInput,
-    setInputFocused,
-    setInputBlurred,
-    type ISymbioteEvent,
-    type ISymbioteNode,
-    type IMeasureOnSuccess,
-    type IMeasureInWindowOnSuccess,
-    type IMeasureLayoutOnSuccess,
-  } from '@symbiote-native/engine';
-  import { createDescriptorChildrenSync } from '../../descriptor-to-svelte';
-  import { createAttachmentsSync } from '../../runes/attachments';
-  import type { ShimElement } from '../../dom-shim';
-
-  // The exact destructure list React's index.ts pulls out of props before building
-  // `passthrough` (everything else rides through to Fabric untouched — placeholder,
-  // secureTextEntry, style, class, testID, the remaining native events, the accessibility*
-  // props already folded below). `class`/`style` are deliberately NOT here, same as Vue's
-  // HANDLED_ATTRS, so they forward like every other adapter's TextInput.
-  const HANDLED_KEYS: readonly string[] = [
-    'defaultValue',
-    'multiline',
-    'selection',
-    'onValueChange',
-    'onFocus',
-    'onBlur',
-    'inputMode',
-    'enterKeyHint',
-    'readOnly',
-    'submitBehavior',
-    'blurOnSubmit',
-    'cursorColor',
-    'selectionColor',
-    'selectionHandleColor',
-    'keyboardType',
-    'returnKeyType',
-    'editable',
-    'autoComplete',
-    'textContentType',
-    'autoFocus',
-    'showSoftInputOnFocus',
-    'underlineColorAndroid',
-  ];
-
-  // `resolveAccessibilityProps` only transforms accessibility*/aria-*/role fields, so it's
-  // applied HERE, once, at the one place that needs the folded result, rather than wrapped
-  // around the whole props object in an outer $derived — every other derived/effect keeps a
-  // plain, direct property read on the raw `$props()` proxy. `source` is a closed interface (no
-  // index signature), so `Object.keys` + bracket-indexing would need an `as` cast; `Object.entries`
-  // falls onto TS's `entries(o: {}): [string, any][]` overload instead, which needs no cast.
-  function forwardProps(
-    source: Omit<ITextInputProps, 'value'>,
-  ): Record<string, unknown> {
-    const resolved = resolveAccessibilityProps(source);
-    const result: Record<string, unknown> = {};
-    for (const [key, propValue] of Object.entries(resolved)) {
-      if (!HANDLED_KEYS.includes(key)) result[key] = propValue;
-    }
-    return result;
-  }
-
-  // `value` is $bindable() (see the module-script header for the full reasoning); everything
-  // else keeps flowing through `rest`, the exact twin of the old whole-object `rawProps` for
-  // every non-`value` field.
-  let { value = $bindable(), ...rest }: ITextInputProps = $props();
-
-  // $state.raw, NOT $state: identity concern, see the module-script header above.
-  let hostShim = $state.raw<ShimElement | null>(null);
-
-  // The count native last acknowledged. $state so the bag echoes it back on every commit and
-  // the exposed handle reads the latest (the Svelte twin of React's useState / Vue's ref).
-  let mostRecentEventCount = $state(INITIAL_EVENT_COUNT);
-  // The last text native holds, as far as JS knows. Seeded from the mount-time value — the
-  // `text` prop already carries it down via the bag, so the FIRST controlled value is not a
-  // divergence and must NOT re-command. Bookkeeping, not render state: a plain `let`, same as
-  // Vue's setup-scope `let lastNativeText`.
-  let lastNativeText = foldText(value, rest.defaultValue);
-  // JS-side focus state, mirrored from the focus/blur events for isFocused(): native exposes no
-  // synchronous focus getter (RN's TextInputState keeps the same).
-  let focused = false;
-  // autoFocus fires once, when the host node first goes live; guarded so a later re-render (or
-  // an intrinsic swap between single/multiline) doesn't re-focus.
-  let autoFocused = false;
-
-  const isMultiline = $derived(rest.multiline === true);
-  const text = $derived(foldText(value, rest.defaultValue));
-  const folded = $derived(
-    resolveTextInputProps({
-      inputMode: rest.inputMode,
-      keyboardType: rest.keyboardType,
-      enterKeyHint: rest.enterKeyHint,
-      returnKeyType: rest.returnKeyType,
-      readOnly: rest.readOnly,
-      editable: rest.editable,
-      submitBehavior: rest.submitBehavior,
-      blurOnSubmit: rest.blurOnSubmit,
-      multiline: isMultiline,
-      cursorColor: rest.cursorColor,
-      selectionColor: rest.selectionColor,
-      selectionHandleColor: rest.selectionHandleColor,
-      autoComplete: rest.autoComplete,
-      textContentType: rest.textContentType,
-      showSoftInputOnFocus: rest.showSoftInputOnFocus,
-      underlineColorAndroid: rest.underlineColorAndroid,
-    }),
-  );
-
-  function handleChange(event: ISymbioteEvent): void {
-    // Event seam: the controlled handshake hinges on the change payload carrying `text`
-    // (+ `eventCount`). iOS and Android Fabric can key these differently, so log the actual
-    // shape here; a missing `text` means onValueChange never fires.
-    dlog(
-      `TextInput change keys=[${Object.keys(event.nativeEvent).join(',')}] ` +
-        `text=${JSON.stringify(event.nativeEvent.text)} count=${JSON.stringify(event.nativeEvent.eventCount)}`,
-    );
-    const changedText = textFromChange(event);
-    if (changedText !== undefined) {
-      // Record the text first, then bump the acknowledged count, so the count never runs ahead
-      // of the text it stands for.
-      lastNativeText = changedText;
-      rest.onValueChange?.(changedText, event);
-      // $bindable() sugar: with no onValueChange nothing could reject this report, so mirror it
-      // straight into the bound value. A caller that ALSO supplies onValueChange keeps full
-      // accept/reject control via the controlled-write effect below — see the module-script
-      // header for why echoing unconditionally would break that for it too.
-      if (rest.onValueChange === undefined) value = changedText;
-    }
-    const count = eventCountFromChange(event);
-    if (count !== undefined) mostRecentEventCount = count;
-  }
-
-  function handleFocus(event: ISymbioteEvent): void {
-    focused = true;
-    // Track focus app-wide so Keyboard.dismiss can blur this input without a ref.
-    const engineNode = hostShim?.engineNode;
-    if (engineNode !== undefined) setInputFocused(engineNode);
-    rest.onFocus?.(event);
-  }
-
-  function handleBlur(event: ISymbioteEvent): void {
-    focused = false;
-    const engineNode = hostShim?.engineNode;
-    if (engineNode !== undefined) setInputBlurred(engineNode);
-    rest.onBlur?.(event);
-  }
-
-  // Controlled write: when JS-side `value` diverges from what native reported, command the new
-  // text down with the acknowledged count — a plain prop re-push would race the user's
-  // keystrokes; the command is the only stale-safe path. `value` and `count` are read
-  // UNCONDITIONALLY up front, before either early return: a rejecting parent never changes
-  // `props.value`, only `mostRecentEventCount` (bumped inside handleChange), so reading `count`
-  // only after the `shouldCommandText` guard would drop it from the tracked dependency set on the
-  // run that first falls through, and a later event-count-only change would then silently fail
-  // to retrigger this effect (same class of bug Switch's snap-back effect avoids). Verified
-  // against a real compiled mount (text-input.smoke.test.ts): the shim's insertOne() calls
-  // makeLive() synchronously as part of the SAME appendChild/insertBefore the compiler emits,
-  // before `bind:this` fires, so `hostShim.engineNode` is always populated by the time this
-  // first runs.
-  $effect(() => {
-    const engineNode = hostShim?.engineNode;
-    // `value` (component-scope, now $bindable()) IS the authoritative prop read — no local
-    // shadow needed; reading it here still establishes the effect's dependency exactly as the
-    // old `const value = rawProps.value` line did.
-    const currentValue = value;
-    const count = mostRecentEventCount;
-    if (engineNode === undefined) return;
-    if (!shouldCommandText(lastNativeText, currentValue)) return;
-    const selStart = rest.selection?.start ?? SELECTION_NONE;
-    const selEnd =
-      rest.selection?.end ?? rest.selection?.start ?? SELECTION_NONE;
-    dlog(
-      `TextInput setTextAndSelection count=${count} text=${JSON.stringify(currentValue)}`,
-    );
-    dispatchViewCommand(engineNode, 'setTextAndSelection', [
-      count,
-      currentValue,
-      selStart,
-      selEnd,
-    ]);
-    lastNativeText = currentValue;
-  });
-
-  // autoFocus is driven in JS, not as a native prop: once the host node first goes live, command
-  // `focus` down once (RN does the same via TextInputState.focusInput). No commit-timing retry
-  // needed here (unlike Vue's whenCommitted) — same synchronous makeLive() guarantee the
-  // controlled-write effect above relies on.
-  $effect(() => {
-    const engineNode = hostShim?.engineNode;
-    if (autoFocused || engineNode === undefined || rest.autoFocus !== true)
-      return;
-    autoFocused = true;
-    dlog('TextInput autoFocus -> focus command');
-    dispatchViewCommand(engineNode, 'focus', []);
-  });
-
-  // The imperative API RN exposes on a TextInput ref, as plain instance-script functions — the
-  // Svelte 5 mechanism (no useImperativeHandle/expose() rune): a parent's `bind:this={ref}` gets
-  // `ref.focus()` etc. callable directly, typed via the re-exported `ITextInputHandle` above.
-  // focus/blur drive native view commands; clear/setSelection reuse setTextAndSelection (the
-  // same stale-safe path as a controlled write), echoing the acknowledged event count.
-  export function focus(): void {
-    const engineNode = hostShim?.engineNode;
-    if (engineNode !== undefined) dispatchViewCommand(engineNode, 'focus', []);
-  }
-
-  export function blur(): void {
-    // Routes through TextInputState so the app-wide focus tracking clears too.
-    blurTextInput(hostShim?.engineNode ?? null);
-  }
-
-  export function clear(): void {
-    const engineNode = hostShim?.engineNode;
-    if (engineNode === undefined) return;
-    dispatchViewCommand(engineNode, 'setTextAndSelection', [
-      mostRecentEventCount,
-      '',
-      0,
-      0,
-    ]);
-    lastNativeText = '';
-  }
-
-  export function isFocused(): boolean {
-    return focused;
-  }
-
-  export function setSelection(start: number, end: number): void {
-    const engineNode = hostShim?.engineNode;
-    if (engineNode === undefined) return;
-    const current = lastNativeText ?? '';
-    dispatchViewCommand(engineNode, 'setTextAndSelection', [
-      mostRecentEventCount,
-      current,
-      start,
-      end,
-    ]);
-  }
-
-  // The four host-ref methods, FORWARDED to the engine node rather than reimplemented.
-  //
-  // Without them a TextInput ref was poorer than any other host ref in the adapter: every other
-  // primitive hands back a node carrying measure/measureInWindow/measureLayout/setNativeProps, and
-  // this wrapper closed the node behind five methods of its own. The lowered path lost the opposite
-  // four, so the two paths were not "one narrowing the other" but two different surfaces.
-  // `ITextInputHandle` is the union of both halves, and `text-input.smoke.test.ts` derives what this
-  // component must expose from `buildTextInputHandle` — so a method added to core fails here rather
-  // than going missing on whichever path an app happened to take.
-  //
-  // Not typed as `satisfies ITextInputHandle`: these are instance-script exports, so the component's
-  // imperative surface is structurally invisible to the compiler — which is exactly why the test is
-  // the guard here and the type is the guard on React, Angular and Solid.
-  export function measure(callback: IMeasureOnSuccess): void {
-    hostShim?.engineNode?.measure(callback);
-  }
-
-  export function measureInWindow(callback: IMeasureInWindowOnSuccess): void {
-    hostShim?.engineNode?.measureInWindow(callback);
-  }
-
-  export function measureLayout(
-    relativeToNativeNode: ISymbioteNode | number,
-    onSuccess: IMeasureLayoutOnSuccess,
-    onFail?: () => void,
-  ): void {
-    hostShim?.engineNode?.measureLayout(
-      relativeToNativeNode,
-      onSuccess,
-      onFail,
-    );
-  }
-
-  export function setNativeProps(nativeProps: Record<string, unknown>): void {
-    hostShim?.engineNode?.setNativeProps(nativeProps);
-  }
-
-  const descriptor = $derived(
-    renderTextInput({
-      multiline: isMultiline,
-      text,
-      mostRecentEventCount,
-      selection: rest.selection,
-      folded,
-      passthrough: {
-        ...forwardProps(rest),
-        onChange: handleChange,
-        onFocus: handleFocus,
-        onBlur: handleBlur,
-      },
-    }),
-  );
-
-  // renderTextInput()'s Descriptor has zero children (the whole surface is the `text`/
-  // `mostRecentEventCount` prop handshake) — wired anyway for the same uniform-shape reason
-  // Switch is, see its header comment.
-  const syncChildren = createDescriptorChildrenSync();
-  $effect(() => {
-    syncChildren(hostShim, descriptor.children);
-  });
-
-  // See View.svelte's note on `{@attach}`. `rest` (not `value`, which never carries a symbol
-  // key) is the same attachment-bearing bag `rawProps` used to be.
-  const syncAttachments = createAttachmentsSync();
-  $effect(() => {
-    syncAttachments(hostShim, rest);
-  });
-</script>
-
-<!--
-  The `-managed` tags, matching `renderTextInput`'s intrinsics. They resolve to the SAME native view
-  as the plain ones; the separate spelling is what keeps the host behavior off this node. The machine
-  is registered against `symbiote-text-input` / `…-multiline`, which only the LOWERING transform
-  emits, and this wrapper runs the same lifecycle itself (focus/blur mirror, event counter,
-  controlled write, autoFocus) — so sharing a tag would give one node two owners.
-
-  Written literally rather than as `<svelte:element this={descriptor.type}>` for the reason the
-  header records, which means this pair does NOT follow `render-text-input.ts` on its own: if those
-  intrinsics are renamed again, this file has to move with them. `text-input-tag.test.ts` is what
-  makes that a failing test instead of a silent double-owner.
--->
-{#if isMultiline}
-  <symbiote-text-input-multiline-managed
-    p={descriptor.props}
-    bind:this={hostShim}
-  />
-{:else}
-  <symbiote-text-input-managed p={descriptor.props} bind:this={hostShim} />
-{/if}

package/build/components/text-input/index.svelte.d.ts

@@ -1,17 +0,0 @@
-import type { ITextInputProps } from './text-input-props';
-export type { ITextInputProps };
-export type { ITextInputHandle } from '@symbiote-native/components';
-import { type ISymbioteNode, type IMeasureOnSuccess, type IMeasureInWindowOnSuccess, type IMeasureLayoutOnSuccess } from '@symbiote-native/engine';
-declare const Index: import("svelte").Component<ITextInputProps, {
-    focus: () => void;
-    blur: () => void;
-    clear: () => void;
-    isFocused: () => boolean;
-    setSelection: (start: number, end: number) => void;
-    measure: (callback: IMeasureOnSuccess) => void;
-    measureInWindow: (callback: IMeasureInWindowOnSuccess) => void;
-    measureLayout: (relativeToNativeNode: ISymbioteNode | number, onSuccess: IMeasureLayoutOnSuccess, onFail?: () => void) => void;
-    setNativeProps: (nativeProps: Record<string, unknown>) => void;
-}, "value">;
-type Index = ReturnType<typeof Index>;
-export default Index;

package/build/components/touchable-highlight/index.svelte

@@ -1,139 +0,0 @@
-<script lang="ts" module>
-  // TouchableHighlight: built on Pressable. Ported against RN's own source
-  // (.vendors/react-native/.../Components/Touchable/TouchableHighlight.js) after the 2026-08-19
-  // audit; Solid migrated first, then React, Vue and Angular, and this is Svelte.
-  //
-  // RN drives the underlay from THREE Pressability callbacks, not from a `pressed` flag, and the
-  // difference is visible: onPress re-shows the underlay and holds it for delayPressOut, so a tap
-  // too fast to see still flashes. The previous port derived the highlight from Pressable's
-  // `pressed` through `highlightPressedStyle`, which cannot express that hold — the flag is
-  // already false by then. The machine itself
-  // (createHighlightUnderlayHandlers) is shared; Svelte owns the reactive `shown` cell and the
-  // real timers.
-  import type { ITouchableHighlightProps } from './touchable-highlight-props';
-
-  export type { ITouchableHighlightProps };
-</script>
-
-<script lang="ts">
-  import {
-    createHighlightUnderlayHandlers,
-    createHighlightUnderlayRuntime,
-    hasTouchablePressHandler,
-    resolveHighlightExtraStyles,
-  } from '@symbiote-native/components';
-  import type {
-    ISymbioteEvent,
-    IStyleProp,
-    IViewStyle,
-  } from '@symbiote-native/engine';
-  import Pressable from '../pressable/index.svelte';
-
-  function scheduleTimeout(callback: () => void, ms: number): () => void {
-    const id = setTimeout(callback, ms);
-    return () => clearTimeout(id);
-  }
-
-  // onPress/onPressIn/onPressOut are INTERCEPTED, not forwarded: RN drives the underlay from
-  // those three and then calls the caller's. delayPressOut is CONSUMED (it is the underlay hold),
-  // so it must not also reach the host as an unknown Fabric prop. onLongPress deliberately stays
-  // in `rest` — Pressable fires it directly — and is only READ here, for the has-handler gate.
-  let {
-    activeOpacity,
-    underlayColor,
-    style,
-    delayPressOut = 0,
-    onPress,
-    onPressIn,
-    onPressOut,
-    onShowUnderlay,
-    onHideUnderlay,
-    children: content,
-    ...rest
-  }: ITouchableHighlightProps = $props();
-
-  // `shown` is NOT `pressed`: RN holds the underlay past the tap for delayPressOut.
-  let shown = $state(false);
-  // Setup-scope only, mutated by the machine on every event and never read reactively — same as
-  // Pressable's own runtime, never `$state`.
-  const runtime = createHighlightUnderlayRuntime();
-
-  // RN's _hasPressHandler gate: a TouchableHighlight with no press callback is decorative, and
-  // flashing an underlay under a touch passing through it is wrong.
-  const hasPressHandler = $derived(
-    hasTouchablePressHandler({
-      onPress,
-      onPressIn,
-      onPressOut,
-      onLongPress: rest.onLongPress,
-    }),
-  );
-
-  // Rebuilt whenever the config changes; the runtime persists across rebuilds so an in-flight
-  // hide timer survives one.
-  const underlay = $derived(
-    createHighlightUnderlayHandlers(
-      { delayPressOut, hasPressHandler, schedule: scheduleTimeout },
-      runtime,
-      {
-        setShown(next: boolean): void {
-          shown = next;
-        },
-        onShowUnderlay: () => onShowUnderlay?.(),
-        onHideUnderlay: () => onHideUnderlay?.(),
-      },
-    ),
-  );
-
-  const extra = $derived(
-    resolveHighlightExtraStyles({
-      shown,
-      hasPressHandler,
-      underlayColor,
-      activeOpacity,
-    }),
-  );
-
-  // ITEM 7 IS DELIBERATELY NOT FIXED HERE, and this is the whole of the divergence from RN. RN
-  // clones its single child with `extra.child`, so the lowered opacity lands on the CHILD while
-  // the container keeps an opaque underlay; React does that with cloneElement and Vue with
-  // cloneVNode. Svelte hands a component an opaque `Snippet` — a function that renders into an
-  // anchor. It cannot be introspected, cloned, or given a prop, and it may have several roots, so
-  // there is NO way to reach the child short of a permanent wrapper View. That wrapper would sit
-  // in the flex chain between this container and the children and silently re-parent any `flex`
-  // they declare; the fake Fabric runs no Yoga, so no headless test can measure the damage.
-  // Shipping an unmeasurable layout change is worse than the visual approximation, so both styles
-  // stay on the container (the child style folded in LAST), exactly as Solid and Angular decided.
-  // resolveHighlightExtraStyles keeps them separate regardless, so a future fix — which needs a
-  // real device, not a test — is unblocked.
-  const containerStyle = $derived<IStyleProp<IViewStyle>>(
-    extra === undefined ? style : [style, extra.underlay, extra.child],
-  );
-
-  // Visual first, then the caller's callback — RN's order in _createPressabilityConfig.
-  function handlePressIn(event: ISymbioteEvent): void {
-    underlay.handlePressIn(event);
-    onPressIn?.(event);
-  }
-  function handlePress(event: ISymbioteEvent): void {
-    underlay.handlePress(event);
-    onPress?.(event);
-  }
-  function handlePressOut(event: ISymbioteEvent): void {
-    underlay.handlePressOut(event);
-    onPressOut?.(event);
-  }
-</script>
-
-<Pressable
-  __minPressDuration={0}
-  {...rest}
-  style={containerStyle}
-  onPress={handlePress}
-  onPressIn={handlePressIn}
-  onPressOut={handlePressOut}
->
-  {#snippet children()}
-    {@render content?.()}
-  {/snippet}
-</Pressable>

package/build/components/touchable-highlight/index.svelte.d.ts

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

package/build/components/touchable-native-feedback/index.d.ts

@@ -1,9 +0,0 @@
-import { canUseNativeForeground, rippleBackground, selectableBackground, selectableBackgroundBorderless } from '@symbiote-native/components';
-export type { ITouchableNativeFeedbackProps } from './touchable-native-feedback-props';
-export type { INativeFeedbackBackground, IThemeAttrBackground, IRippleBackground, } from '@symbiote-native/components';
-export declare const TouchableNativeFeedback: import("svelte").Component<import("./touchable-native-feedback-props").ITouchableNativeFeedbackProps, {}, ""> & {
-    SelectableBackground: typeof selectableBackground;
-    SelectableBackgroundBorderless: typeof selectableBackgroundBorderless;
-    Ripple: typeof rippleBackground;
-    canUseNativeForeground: typeof canUseNativeForeground;
-};

package/build/components/touchable-native-feedback/index.js

@@ -1,14 +0,0 @@
-// TouchableNativeFeedback's static factories (SelectableBackground/SelectableBackgroundBorderless/
-// Ripple/canUseNativeForeground) mirror RN's own API surface and must live ON the component
-// value — callers reach `TouchableNativeFeedback.Ripple(...)`, exactly like React's
-// `Object.assign(TouchableNativeFeedbackImpl, {...})` and Vue's identical pattern. A `.svelte`
-// file's own `<script module>` block cannot reassign or wrap its own compiled default export, so
-// the statics are attached here, one level up, over the imported component.
-import { canUseNativeForeground, rippleBackground, selectableBackground, selectableBackgroundBorderless, } from '@symbiote-native/components';
-import TouchableNativeFeedbackImpl from './touchable-native-feedback.svelte';
-export const TouchableNativeFeedback = Object.assign(TouchableNativeFeedbackImpl, {
-    SelectableBackground: selectableBackground,
-    SelectableBackgroundBorderless: selectableBackgroundBorderless,
-    Ripple: rippleBackground,
-    canUseNativeForeground,
-});

package/build/components/touchable-native-feedback/touchable-native-feedback.svelte

@@ -1,49 +0,0 @@
-<script lang="ts" module>
-  // TouchableNativeFeedback: Android's ripple/state-drawable touchable, built on Pressable like
-  // the rest of the family. The native ripple props (nativeBackgroundAndroid /
-  // nativeForegroundAndroid) ride a dedicated feedback View nested under the Pressable; on iOS
-  // they are inert. The static factories + background mapping are shared in
-  // @symbiote-native/components/view — this component only attaches them onto the component
-  // value (see this folder's index.ts, which Object.assigns them — a `.svelte` file's own
-  // `<script module>` cannot reassign or wrap its own compiled default export) and nests the
-  // feedback View.
-  import type { ITouchableNativeFeedbackProps } from './touchable-native-feedback-props';
-
-  export type { ITouchableNativeFeedbackProps };
-</script>
-
-<script lang="ts">
-  import {
-    backgroundProps,
-    selectableBackground,
-  } from '@symbiote-native/components';
-  import { dlog } from '@symbiote-native/engine';
-  import Pressable from '../pressable/index.svelte';
-
-  let {
-    background,
-    useForeground = false,
-    children: content,
-    ...rest
-  }: ITouchableNativeFeedbackProps = $props();
-
-  // RN defaults a missing background to SelectableBackground() so the touchable always shows
-  // feedback; mirror that here.
-  const resolved = $derived(background ?? selectableBackground());
-
-  $effect(() => {
-    dlog(
-      `TouchableNativeFeedback render ${resolved.type} useForeground ${useForeground}`,
-    );
-  });
-
-  const nativeProps = $derived(backgroundProps(resolved, useForeground));
-</script>
-
-<Pressable __minPressDuration={0} {...rest}>
-  {#snippet children()}
-    <symbiote-view p={nativeProps}>
-      {@render content?.()}
-    </symbiote-view>
-  {/snippet}
-</Pressable>

package/build/components/touchable-native-feedback/touchable-native-feedback.svelte.d.ts

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