@symbiote-native/angular 0.0.0-canary-20260724081123

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 A. Prokopenko
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,157 @@
+# @symbiote-native/angular
+
+The **Angular adapter** for [SymbioteNative](../../README.md) — render real native iOS/Android views
+from Angular, on the *same* untouched core as React and Vue, with React Native's own renderer
+never in the path. It is a `Renderer2`/`RendererFactory2` whose calls map onto the engine's
+four-call mutation API; `@symbiote-native/engine` does the clone-on-write commit into Fabric.
+
+Angular is the **second proof the core is genuinely framework-agnostic**: a third
+framework, with its own change-detection model and AOT compilation pipeline, driving the
+already-validated engine with zero changes to it.
+
+<div align="center">
+
+![Angular driving real native iOS views through SymbioteNative](../../assets/angular-demo.gif)
+
+</div>
+
+> New to SymbioteNative? The [root README](../../README.md) has the architecture.
+
+---
+
+## Install
+
+```bash
+npm install @symbiote-native/angular react-native @angular/core
+```
+
+`react-native` and `@angular/core` (**>=20**, for stable zoneless change detection) stay your app's
+own top-level dependencies. There's no `create-symbiote` scaffolder yet, so the AOT pipeline
+(`ngc --watch` alongside Metro — see [Run it](#run-it)) and the Metro config come from
+[`examples/angular`](../../examples/angular) rather than a generator.
+
+---
+
+## Use it
+
+The native entry reaches the *same* `registerRunnable` seam as React and Vue — only the adapter
+changes. It hands the surface's `rootTag` to `mount` from `@symbiote-native/angular`, which drives the
+engine through Angular's `Renderer2`:
+
+```js
+// index.js
+import { AppRegistry as RNAppRegistry } from 'react-native';
+import { mount } from '@symbiote-native/angular';
+import { AppComponent } from './App';
+import { name as appName } from './app.json';
+
+// registerRunnable (not registerComponent): RN stores a raw mount callback and never renders
+// it with its own renderer. We mount the Angular app onto the surface's rootTag.
+RNAppRegistry.registerRunnable(appName, ({ rootTag }) => {
+  mount(rootTag, AppComponent);
+});
+```
+
+The app is ordinary standalone Angular — it just imports primitives from `@symbiote-native/angular`
+instead of `react-native`. A tap→increment counter:
+
+```ts
+import { Component, signal } from '@angular/core';
+import { View, Text, Pressable } from '@symbiote-native/angular';
+
+@Component({
+  selector: 'app-root',
+  standalone: true,
+  imports: [View, Text, Pressable],
+  template: `
+    <View [style]="{ padding: 24 }">
+      <Text>Taps: {{ count() }}</Text>
+      <Pressable (press)="count.set(count() + 1)">
+        <Text>Tap me</Text>
+      </Pressable>
+    </View>
+  `,
+})
+export class AppComponent {
+  count = signal(0);
+}
+```
+
+The full canary is [`examples/angular`](../../examples/angular) — a stock RN 0.86 app whose
+[`App.ts`](../../examples/angular/App.ts) exercises the same surface as the React and Vue
+reference canaries, standalone components, zoneless change detection.
+
+---
+
+## Parity — and the one gap
+
+Angular reaches the same 21+ primitives, runtime modules, `Animated` on both drivers, gestures,
+accessibility, and the `VirtualizedList` family as React and Vue. That parity is **structural, not
+hand-copied**: the component logic (state machines + render functions) is written **once** in
+`@symbiote-native/components`, and Angular supplies only its lifecycle (`Renderer2` + zoneless change
+detection + the descriptor→`createElement` bridge).
+
+One deliberate gap, tracked, not blocking the canary — **third-party React component packages**
+(`@react-native-community/slider`) run only under the React adapter: their body calls React hooks
+off the React dispatcher, which is null under Angular. `@symbiote-native/slider` (this repo's own
+wrapper) *does* ship a real Angular build, reachable through the same `createNode`-by-ViewConfig
+path Angular uses for its own primitives — that wrapper is what makes a third-party native view
+usable from a non-React adapter at all.
+
+Angular is on the docs site's live framework switcher alongside React and Vue — otherwise it's at
+full canary parity.
+
+---
+
+## An Angular-specific gotcha — AOT compiles separately from Metro
+
+Angular templates need `ngc` (Angular's own AOT compiler), which Metro cannot run per-file the way
+it transforms a Vue SFC or JSX — `ngc` needs whole-program `compilationMode: 'partial'` first, then
+`@angular/compiler-cli/linker/babel` drops the linked output into Metro per-file. In practice this
+means every `ios`/`android`/`e2e:build:*` script runs `pnpm ng:build` first, and local development
+needs `ngc --watch` running alongside Metro — `scripts/dev-with-watch.sh` in
+[`examples/angular`](../../examples/angular) does exactly that (`ngc --watch` in the background,
+Metro's `react-native start` in the foreground, since Metro reads raw keypresses off stdin and
+can't sit behind a process manager that owns stdin itself).
+
+Angular also requires **zoneless change detection** (`provideZonelessChangeDetection`,
+`@angular/core >=20`) — zone.js fights Hermes, and versions before 20 don't offer a stable
+zoneless API. This is the version floor for the whole adapter, not a suggestion.
+
+---
+
+## Run it
+
+[`examples/angular`](../../examples/angular) is a stock React Native 0.86 app. Requires Node ≥
+22.13 and the [RN environment setup](https://reactnative.dev/docs/set-up-your-environment) (Xcode,
+CocoaPods):
+
+```bash
+cd examples/angular
+pnpm install                   # workspace root already covers this if you ran it there
+bundle install                 # first time only — installs CocoaPods itself
+bundle exec pod install        # fetch native pods
+
+# terminal 1 — ngc --watch (background) + Metro (foreground). DEBUG=1 turns on diagnostic logs.
+DEBUG=1 pnpm dev
+
+# terminal 2 — build + launch (each runs ng:build first)
+pnpm ios                       # iOS simulator
+pnpm android                   # Android emulator
+```
+
+---
+
+## Test it
+
+```bash
+pnpm test                      # vitest, from the workspace root — headless, fake Fabric slot
+
+cd examples/angular
+pnpm e2e:build:ios             # ng:build, then build the app for Detox
+pnpm e2e:test:ios              # run the canary journeys on the iOS simulator
+# …or the android equivalents: e2e:build:android / e2e:test:android
+```
+
+Why these come for free — a SymbioteNative app is a stock RN app underneath, so RN's whole testing
+ecosystem applies unchanged. See [Testing](../../README.md#testing).

package/babel-linker.cjs

@@ -0,0 +1,7 @@
+// Normalizes @angular/compiler-cli/linker/babel's export shape — depending on how a
+// consumer's Metro/Babel setup loads it, the plugin lands as either the plugin function itself
+// or a `{ default: plugin }` wrapper — so a consumer's babel.config.js just requires this
+// instead of re-deriving the `.default ?? angularLinker` fallback itself.
+const angularLinkerModule = require('@angular/compiler-cli/linker/babel');
+
+module.exports = angularLinkerModule.default ?? angularLinkerModule;

package/babel-register-composed.cjs

@@ -0,0 +1,127 @@
+// Auto-registers ANCHOR_HOST_COMPONENTS from compiled @Component metadata, replacing
+// hand-written registerComposedComponent(...) calls (see the angular-adapter skill §11).
+// Runs in the SAME Babel pass as babel-linker.cjs, BEFORE it — Stage A (ngc --compilationMode
+// partial) emits ɵɵngDeclareComponent({..., selector}) calls; the linker only turns those into
+// full Ivy afterwards, so this plugin must see the simpler pre-link shape (see
+// angular-adapter-build skill §1).
+//
+// Primitive selectors are hardcoded here (not required from the .ts source — this is a plain
+// .cjs Babel plugin Metro loads via a raw require(), no transpile step available) — source of
+// truth: core/components/src/component-names/index.ios.ts's ISymbioteIntrinsic union. Kept in
+// sync by the drift-protection test in babel-register-composed.test.ts.
+const PRIMITIVE_SELECTORS = new Set([
+  'symbiote-view',
+  'symbiote-text',
+  'symbiote-image',
+  'symbiote-scroll-view',
+  'symbiote-scroll-content',
+  'symbiote-horizontal-scroll-view',
+  'symbiote-horizontal-scroll-content',
+  'symbiote-text-input',
+  'symbiote-text-input-multiline',
+  'symbiote-switch',
+  'symbiote-activity-indicator',
+  'symbiote-safe-area-view',
+  'symbiote-modal',
+  'symbiote-refresh-control',
+  'symbiote-input-accessory-view',
+]);
+
+// Inject from the package barrel — the ONE resolution route every consumer already uses, so the
+// leaf's registry Set stays a single module instance. `registerComposedComponent` is re-exported
+// from the barrel straight off the dependency-free leaf `anchor-host-registry.ts`, so importing it
+// here does NOT drag in the cyclic renderer graph, yet resolves to the same leaf Set that
+// `createElement` reads. (An earlier attempt injected a dedicated `.../anchor-host-registry`
+// subpath instead; under pnpm symlinks that gave the leaf a SECOND resolved path — a second Set —
+// so navigation-package registrations and createElement's lookup desynced. See the leaf header +
+// angular-adapter §11c.)
+const IMPORT_SOURCE = '@symbiote-native/angular';
+const HELPER_NAME = 'registerComposedComponent';
+
+function isNgDeclareComponentCall(node) {
+  return (
+    node.type === 'CallExpression' &&
+    node.callee.type === 'MemberExpression' &&
+    !node.callee.computed &&
+    node.callee.property.type === 'Identifier' &&
+    node.callee.property.name === 'ɵɵngDeclareComponent'
+  );
+}
+
+function selectorPropertyOf(objectExpression) {
+  return objectExpression.properties.find(
+    prop =>
+      prop.type === 'ObjectProperty' &&
+      !prop.computed &&
+      ((prop.key.type === 'Identifier' && prop.key.name === 'selector') ||
+        (prop.key.type === 'StringLiteral' && prop.key.value === 'selector')),
+  );
+}
+
+function composedSelectorsFromCall(node) {
+  const [arg] = node.arguments;
+  if (!arg || arg.type !== 'ObjectExpression') return [];
+  const selectorProp = selectorPropertyOf(arg);
+  if (!selectorProp || selectorProp.value.type !== 'StringLiteral') return [];
+  return selectorProp.value.value
+    .split(',')
+    .map(token => token.trim())
+    .filter(token => token.length > 0 && !PRIMITIVE_SELECTORS.has(token));
+}
+
+function hasComposedImport(programNode) {
+  return programNode.body.some(
+    node =>
+      node.type === 'ImportDeclaration' &&
+      node.source.value === IMPORT_SOURCE &&
+      node.specifiers.some(
+        spec =>
+          spec.type === 'ImportSpecifier' &&
+          spec.imported.type === 'Identifier' &&
+          spec.imported.name === HELPER_NAME,
+      ),
+  );
+}
+
+// Exposed as a property on the plugin function (not a separate export) so Babel still loads
+// this file as a plain plugin factory; babel-register-composed.test.ts's drift-protection test
+// reads it to compare against core/components/src/component-names/index.{ios,android}.ts.
+module.exports = function registerComposedPlugin({ types: t }) {
+  return {
+    name: 'symbiote-register-composed',
+    visitor: {
+      Program(programPath) {
+        const selectors = new Set();
+        programPath.traverse({
+          CallExpression(path) {
+            if (isNgDeclareComponentCall(path.node)) {
+              for (const selector of composedSelectorsFromCall(path.node)) selectors.add(selector);
+            }
+          },
+        });
+        if (selectors.size === 0) return;
+
+        const statements = [...selectors].map(selector =>
+          t.expressionStatement(
+            t.callExpression(t.identifier(HELPER_NAME), [t.stringLiteral(selector)]),
+          ),
+        );
+
+        if (!hasComposedImport(programPath.node)) {
+          statements.unshift(
+            t.importDeclaration(
+              [t.importSpecifier(t.identifier(HELPER_NAME), t.identifier(HELPER_NAME))],
+              t.stringLiteral(IMPORT_SOURCE),
+            ),
+          );
+        }
+
+        // Import hoisting makes textual position irrelevant to `registerComposedComponent`'s
+        // availability, so unshifting the whole batch to the top keeps this single-pass.
+        programPath.unshiftContainer('body', statements);
+      },
+    },
+  };
+};
+
+module.exports.PRIMITIVE_SELECTORS = PRIMITIVE_SELECTORS;

package/bin/symbiote-angular-dev.cjs

@@ -0,0 +1,93 @@
+#!/usr/bin/env node
+// Cross-platform replacement for the old per-app dev-with-watch.sh: Angular needs a pre-Metro
+// AOT compile (ngc), kept in sync via `ngc --watch` while developing. Metro itself must stay
+// the FOREGROUND process — it reads raw keypresses
+// (r/j/d/...) straight off stdin, and any wrapper that pipes stdin through itself
+// (concurrently, npm-run-all, ...) breaks that raw-mode read. So ngc runs as a plain background
+// child process, never a stdin-owning process manager. `shell: true` resolves `ngc`/
+// `react-native` off PATH exactly like the bash script did — npm/pnpm/yarn already prepend
+// every `node_modules/.bin` up the tree to PATH for any script invocation, this one included.
+const { spawn, spawnSync } = require('node:child_process');
+const path = require('node:path');
+const fs = require('node:fs');
+const ts = require('typescript');
+
+const TSCONFIG = 'tsconfig.angular.json';
+const metroArgs = process.argv.slice(2);
+const projectRoot = process.cwd();
+
+// perform_watch.js chokidar-watches angularCompilerOptions.basePath recursively (filtered only
+// by a hardcoded node_modules/.dotfiles/.js/.map/.metadata.json regex — never ios/android/build),
+// so an app's tsconfig.angular.json narrows basePath to its own src/ to keep the native platform
+// trees out of the watch (see that file's own comment for the EMFILE story this fixes). That
+// value is written relative (portable, checked in) — but @angular/compiler-cli's INCREMENTAL
+// recompile path (oldProgram reuse, only reachable once `ngc --watch` is already running) calls
+// absoluteFrom() on basePath directly and throws "TS500: ... path is not absolute" if it isn't
+// already absolute, even though the initial cold compile tolerates a relative one fine. Resolve
+// it here, at spawn time, into a throwaway override config — the checked-in tsconfig itself never
+// carries a machine-specific absolute path.
+function resolveWatchTsconfig(tsconfigName) {
+  const realPath = path.resolve(projectRoot, tsconfigName);
+  const { config, error } = ts.readConfigFile(realPath, ts.sys.readFile);
+  const basePath = config?.angularCompilerOptions?.basePath;
+  if (error || typeof basePath !== 'string' || path.isAbsolute(basePath)) {
+    return realPath;
+  }
+  // Written inside the project (build/, already gitignored everywhere this script runs) rather
+  // than os.tmpdir() — TS resolves default typeRoots/@types by walking up from the extending
+  // config's OWN directory, and a tmpdir has no node_modules above it, so an os.tmpdir() location
+  // broke `@types/node` resolution (TS2688) even though the extended real config was found fine.
+  const buildDir = path.resolve(projectRoot, 'build');
+  fs.mkdirSync(buildDir, { recursive: true });
+  const watchConfigPath = path.join(buildDir, `symbiote-angular-dev-watch-${process.pid}.json`);
+  fs.writeFileSync(
+    watchConfigPath,
+    JSON.stringify({
+      extends: realPath,
+      angularCompilerOptions: { basePath: path.resolve(projectRoot, basePath) },
+    }),
+  );
+  return watchConfigPath;
+}
+
+// Without watchman, Metro falls back to chokidar's native fs.watch, which opens one OS file
+// handle per watched directory. This project's watchFolders spans the whole monorepo, so that
+// reliably blows past macOS's per-process fd limit (EMFILE) — doubly likely here since ngc
+// --watch adds a second watcher on top of Metro's own. Warn instead of letting everyone
+// individually debug a native stack trace down to this one missing binary.
+const watchmanCheck = spawnSync('watchman', ['--version'], { stdio: 'ignore', shell: true });
+if (watchmanCheck.status !== 0) {
+  console.warn(
+    '[symbiote-angular-dev] watchman not found on PATH. Metro will fall back to watching files ' +
+      'itself, which commonly crashes with "EMFILE: too many open files" on a repo this size. ' +
+      'Install it: https://facebook.github.io/watchman/docs/install (macOS: brew install watchman).',
+  );
+}
+
+const initialBuild = spawnSync('ngc', ['-p', TSCONFIG], { stdio: 'inherit', shell: true });
+if (initialBuild.status !== 0) {
+  process.exit(initialBuild.status ?? 1);
+}
+
+const watchTsconfigPath = resolveWatchTsconfig(TSCONFIG);
+const ngcWatch = spawn('ngc', ['-p', watchTsconfigPath, '--watch'], { stdio: 'inherit', shell: true });
+const metro = spawn('react-native', ['start', ...metroArgs], { stdio: 'inherit', shell: true });
+
+function stopNgcWatch() {
+  ngcWatch.kill();
+  if (watchTsconfigPath !== path.resolve(projectRoot, TSCONFIG)) {
+    fs.rmSync(watchTsconfigPath, { force: true });
+  }
+}
+
+metro.on('exit', (code) => {
+  stopNgcWatch();
+  process.exit(code ?? 0);
+});
+
+for (const signal of ['SIGINT', 'SIGTERM']) {
+  process.on(signal, () => {
+    stopNgcWatch();
+    metro.kill(signal);
+  });
+}

package/build/angular/anchor-host-registry.d.ts

@@ -0,0 +1,2 @@
+export declare function registerComposedComponent(selector: string): void;
+export declare function isAnchorHostComponent(engineName: string): boolean;

package/build/angular/anchor-host-registry.js

@@ -0,0 +1,84 @@
+// Registry of composed-component selectors that must NOT paint a native view of their own.
+//
+// A dependency-free LEAF module (imports nothing from the adapter barrel `./index` or
+// `./components`, both deeply require-cyclic). Both consumers reach it by RELATIVE path — the
+// renderer imports `isAnchorHostComponent` from `../anchor-host-registry`, the barrel re-exports
+// `registerComposedComponent` from `./anchor-host-registry` — so Metro keys it to ONE module
+// instance / ONE Set. Do NOT give it a package `exports` subpath and inject THAT bare specifier
+// into app code: a subpath resolves via a different path than the relative imports under pnpm
+// symlinks, which splits the Set in two.
+//
+// Housing the registry here rather than inline in `renderer/index.ts` keeps it out of the require
+// cycle (cheap insurance against a load-order strand). The bug that actually surfaced this,
+// though, was STALE BUILD ARTIFACTS, not the cycle: `ngc -p` never deletes orphaned outputs, so
+// after the renderer moved `renderer.ts` → `renderer/index.ts` the orphaned `build/angular/
+// renderer.js` lingered and SHADOWED `build/angular/renderer/index.js` (a file beats a folder in
+// Node/Metro resolution), giving the bundle a second, stale registry Set — fixed by cleaning
+// `build/` before every ngc build (see each Angular package's `clean` script). Full record:
+// angular-adapter §11c, symbiote-dev-examples §5e.
+// Lowercased at construction — isAnchorHostComponent and registerComposedComponent both normalize
+// to lowercase (Angular lowercases a dynamically-mounted component's selector at runtime, see
+// angular-adapter §11a), so the literal entries below must match that or every capitalized one
+// (all but the handful already written lowercase) silently never matches .has() and falls through
+// to a real Fabric createNode — the exact "Unimplemented component" / extra-wrapper-node bug this
+// Set exists to prevent.
+const ANCHOR_HOST_COMPONENTS = new Set([
+    // Composed Angular components render their real Fabric descriptor tree from the template;
+    // their Angular host element is only a framework bookkeeping node and must not paint. This
+    // is NOT limited to adapter-authored components — ANY custom composed @Component used as a
+    // plain <Tag> inside another template needs its selector listed here too, or Angular's
+    // automatic host-element creation for it falls through to a raw Fabric createNode call with
+    // an unrecognized view name, which paints RN's own "Unimplemented component: <Tag>" fallback
+    // view instead (a real device-visible bug, not a silent no-op). This Set holds only
+    // adapter/engine-owned selectors; app code and third-party packages self-register their own
+    // composed components through registerComposedComponent instead of being hardcoded here.
+    'ActivityIndicator',
+    'Button',
+    'FlatList',
+    'AnimatedView',
+    'symbiote-animated-view',
+    'AnimatedText',
+    'symbiote-animated-text',
+    'AnimatedImage',
+    'symbiote-animated-image',
+    'AnimatedScrollView',
+    'symbiote-animated-scroll-view',
+    'symbiote-descriptor-outlet',
+    'tunnel-out',
+    'Image',
+    'ImageBackground',
+    'InputAccessoryView',
+    'KeyboardAvoidingView',
+    'Modal',
+    'Pressable',
+    'RefreshControl',
+    'SafeAreaView',
+    'ScrollView',
+    'ScrollViewStickyHeader',
+    'SectionList',
+    'symbiote-sticky-header',
+    'StatusBar',
+    'Switch',
+    'Text',
+    'TextInput',
+    'TouchableHighlight',
+    'TouchableNativeFeedback',
+    'TouchableOpacity',
+    'TouchableWithoutFeedback',
+    'VirtualizedList',
+    'VirtualizedSectionList',
+    'symbiote-pressable',
+].map(selector => selector.toLowerCase()));
+// A composed component's selector must be registered so createElement gives it a non-painting
+// anchor host (see the Set comment above). Tests register their own child-component selectors
+// through this at module load; app-authored composed components self-register the same way via
+// the babel-register-composed plugin.
+export function registerComposedComponent(selector) {
+    ANCHOR_HOST_COMPONENTS.add(selector.toLowerCase());
+}
+// True when `engineName` is a composed selector that must anchor-host (not paint). Case-
+// insensitive — the Set is lowercased at construction, so callers pass the raw selector.
+export function isAnchorHostComponent(engineName) {
+    return ANCHOR_HOST_COMPONENTS.has(engineName.toLowerCase());
+}
+//# sourceMappingURL=anchor-host-registry.js.map

package/build/angular/anchor-host-registry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"anchor-host-registry.js","sourceRoot":"","sources":["../../src/anchor-host-registry.ts"],"names":[],"mappings":"AAAA,2FAA2F;AAC3F,EAAE;AACF,sFAAsF;AACtF,8FAA8F;AAC9F,iGAAiG;AACjG,6FAA6F;AAC7F,gGAAgG;AAChG,8FAA8F;AAC9F,yCAAyC;AACzC,EAAE;AACF,kGAAkG;AAClG,4FAA4F;AAC5F,gGAAgG;AAChG,4FAA4F;AAC5F,iGAAiG;AACjG,6FAA6F;AAC7F,4FAA4F;AAC5F,mDAAmD;AAEnD,kGAAkG;AAClG,8FAA8F;AAC9F,+FAA+F;AAC/F,kGAAkG;AAClG,kGAAkG;AAClG,yBAAyB;AACzB,MAAM,sBAAsB,GAAgB,IAAI,GAAG,CACjD;IACE,0FAA0F;IAC1F,2FAA2F;IAC3F,2FAA2F;IAC3F,uFAAuF;IACvF,4FAA4F;IAC5F,6FAA6F;IAC7F,oFAAoF;IACpF,4FAA4F;IAC5F,yFAAyF;IACzF,mBAAmB;IACnB,QAAQ;IACR,UAAU;IACV,cAAc;IACd,wBAAwB;IACxB,cAAc;IACd,wBAAwB;IACxB,eAAe;IACf,yBAAyB;IACzB,oBAAoB;IACpB,+BAA+B;IAC/B,4BAA4B;IAC5B,YAAY;IACZ,OAAO;IACP,iBAAiB;IACjB,oBAAoB;IACpB,sBAAsB;IACtB,OAAO;IACP,WAAW;IACX,gBAAgB;IAChB,cAAc;IACd,YAAY;IACZ,wBAAwB;IACxB,aAAa;IACb,wBAAwB;IACxB,WAAW;IACX,QAAQ;IACR,MAAM;IACN,WAAW;IACX,oBAAoB;IACpB,yBAAyB;IACzB,kBAAkB;IAClB,0BAA0B;IAC1B,iBAAiB;IACjB,wBAAwB;IACxB,oBAAoB;CACrB,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,CAAC,QAAQ,CAAC,WAAW,EAAE,CAAC,CAC1C,CAAC;AAEF,8FAA8F;AAC9F,8FAA8F;AAC9F,+FAA+F;AAC/F,sCAAsC;AACtC,MAAM,UAAU,yBAAyB,CAAC,QAAgB;IACxD,sBAAsB,CAAC,GAAG,CAAC,QAAQ,CAAC,WAAW,EAAE,CAAC,CAAC;AACrD,CAAC;AAED,yFAAyF;AACzF,yFAAyF;AACzF,MAAM,UAAU,qBAAqB,CAAC,UAAkB;IACtD,OAAO,sBAAsB,CAAC,GAAG,CAAC,UAAU,CAAC,WAAW,EAAE,CAAC,CAAC;AAC9D,CAAC"}

package/build/angular/bootstrap.d.ts

@@ -0,0 +1,7 @@
+import type { Type } from '@angular/core';
+import { type IBootstrapHostOptions } from '@symbiote-native/components/bootstrap';
+export type { IBootstrapHostOptions } from '@symbiote-native/components/bootstrap';
+export type IBootstrapApplicationOptions = IBootstrapHostOptions & {
+    appName: string;
+};
+export declare function bootstrapApplication(AppComponent: Type<unknown>, options: IBootstrapApplicationOptions): void;

package/build/angular/bootstrap.js

@@ -0,0 +1,15 @@
+// Zero-config app entry, the Angular twin of adapters/react/src/bootstrap.ts. Lives OUTSIDE the
+// package's main barrel — see that file's header for why anything importing react-native must
+// stay there. No @Component/@Directive decorators here, so unlike the package's main "." entry
+// this needs no ngc/AOT build step and can stay a plain source reference.
+import { AppRegistry as RNAppRegistry } from 'react-native';
+import { bootstrapHost } from '@symbiote-native/components/bootstrap';
+import { AppRegistry, setHostRegistrar } from './modules/app-registry';
+// Mirrors real Angular's bootstrapApplication(RootComponent, config) idiom.
+export function bootstrapApplication(AppComponent, options) {
+    const { appName, ...bootstrapOptions } = options;
+    bootstrapHost(bootstrapOptions);
+    setHostRegistrar(RNAppRegistry);
+    AppRegistry.registerComponent(appName, () => AppComponent);
+}
+//# sourceMappingURL=bootstrap.js.map

package/build/angular/bootstrap.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bootstrap.js","sourceRoot":"","sources":["../../src/bootstrap.ts"],"names":[],"mappings":"AAAA,gGAAgG;AAChG,8FAA8F;AAC9F,+FAA+F;AAC/F,0EAA0E;AAE1E,OAAO,EAAE,WAAW,IAAI,aAAa,EAAE,MAAM,cAAc,CAAC;AAE5D,OAAO,EAAE,aAAa,EAA8B,MAAM,uCAAuC,CAAC;AAClG,OAAO,EAAE,WAAW,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAQvE,4EAA4E;AAC5E,MAAM,UAAU,oBAAoB,CAClC,YAA2B,EAC3B,OAAqC;IAErC,MAAM,EAAE,OAAO,EAAE,GAAG,gBAAgB,EAAE,GAAG,OAAO,CAAC;IACjD,aAAa,CAAC,gBAAgB,CAAC,CAAC;IAChC,gBAAgB,CAAC,aAAa,CAAC,CAAC;IAChC,WAAW,CAAC,iBAAiB,CAAC,OAAO,EAAE,GAAG,EAAE,CAAC,YAAY,CAAC,CAAC;AAC7D,CAAC"}

package/build/angular/components/activity-indicator/index.android.d.ts

@@ -0,0 +1,12 @@
+import { ActivityIndicatorBase } from './shared';
+import * as i0 from "@angular/core";
+export type { IActivityIndicatorProps } from './shared';
+export declare class ActivityIndicator extends ActivityIndicatorBase {
+    protected readonly defaultColor: null;
+    protected readonly nativeExtras: {
+        styleAttr: string;
+        indeterminate: boolean;
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<ActivityIndicator, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ActivityIndicator, "ActivityIndicator", never, {}, {}, never, never, true, never>;
+}

package/build/angular/components/activity-indicator/index.android.js

@@ -0,0 +1,21 @@
+import { ChangeDetectionStrategy, Component } from '@angular/core';
+import { DescriptorOutlet } from '../../descriptor-to-angular';
+import { ActivityIndicatorBase } from './shared';
+import * as i0 from "@angular/core";
+export class ActivityIndicator extends ActivityIndicatorBase {
+    defaultColor = null;
+    nativeExtras = { styleAttr: 'Normal', indeterminate: true };
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.5", ngImport: i0, type: ActivityIndicator, deps: null, target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "22.0.5", type: ActivityIndicator, isStandalone: true, selector: "ActivityIndicator", usesInheritance: true, ngImport: i0, template: `<symbiote-descriptor-outlet [node]="descriptor" />`, isInline: true, dependencies: [{ kind: "component", type: DescriptorOutlet, selector: "symbiote-descriptor-outlet", inputs: ["node"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.5", ngImport: i0, type: ActivityIndicator, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ActivityIndicator',
+                    standalone: true,
+                    imports: [DescriptorOutlet],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: `<symbiote-descriptor-outlet [node]="descriptor" />`,
+                }]
+        }] });
+//# sourceMappingURL=index.android.js.map

package/build/angular/components/activity-indicator/index.android.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.android.js","sourceRoot":"","sources":["../../../../src/components/activity-indicator/index.android.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AACnE,OAAO,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAC;AAC/D,OAAO,EAAE,qBAAqB,EAAE,MAAM,UAAU,CAAC;;AAUjD,MAAM,OAAO,iBAAkB,SAAQ,qBAAqB;IACvC,YAAY,GAAG,IAAI,CAAC;IACX,YAAY,GAAG,EAAE,SAAS,EAAE,QAAQ,EAAE,aAAa,EAAE,IAAI,EAAE,CAAC;uGAF7E,iBAAiB;2FAAjB,iBAAiB,oGAFlB,oDAAoD,4DAFpD,gBAAgB;;2FAIf,iBAAiB;kBAP7B,SAAS;mBAAC;oBACT,QAAQ,EAAE,mBAAmB;oBAC7B,UAAU,EAAE,IAAI;oBAChB,OAAO,EAAE,CAAC,gBAAgB,CAAC;oBAC3B,eAAe,EAAE,uBAAuB,CAAC,MAAM;oBAC/C,QAAQ,EAAE,oDAAoD;iBAC/D"}

package/build/angular/components/activity-indicator/index.d.ts

@@ -0,0 +1 @@
+export * from './index.ios';

package/build/angular/components/activity-indicator/index.ios.d.ts

@@ -0,0 +1,8 @@
+import { ActivityIndicatorBase } from './shared';
+import * as i0 from "@angular/core";
+export type { IActivityIndicatorProps } from './shared';
+export declare class ActivityIndicator extends ActivityIndicatorBase {
+    protected readonly defaultColor = "#999999";
+    static ɵfac: i0.ɵɵFactoryDeclaration<ActivityIndicator, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ActivityIndicator, "ActivityIndicator", never, {}, {}, never, never, true, never>;
+}

package/build/angular/components/activity-indicator/index.ios.js

@@ -0,0 +1,21 @@
+import { ChangeDetectionStrategy, Component } from '@angular/core';
+import { DescriptorOutlet } from '../../descriptor-to-angular';
+import { ActivityIndicatorBase } from './shared';
+import * as i0 from "@angular/core";
+const IOS_DEFAULT_COLOR = '#999999';
+export class ActivityIndicator extends ActivityIndicatorBase {
+    defaultColor = IOS_DEFAULT_COLOR;
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.5", ngImport: i0, type: ActivityIndicator, deps: null, target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "22.0.5", type: ActivityIndicator, isStandalone: true, selector: "ActivityIndicator", usesInheritance: true, ngImport: i0, template: `<symbiote-descriptor-outlet [node]="descriptor" />`, isInline: true, dependencies: [{ kind: "component", type: DescriptorOutlet, selector: "symbiote-descriptor-outlet", inputs: ["node"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.5", ngImport: i0, type: ActivityIndicator, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ActivityIndicator',
+                    standalone: true,
+                    imports: [DescriptorOutlet],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: `<symbiote-descriptor-outlet [node]="descriptor" />`,
+                }]
+        }] });
+//# sourceMappingURL=index.ios.js.map

package/build/angular/components/activity-indicator/index.ios.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.ios.js","sourceRoot":"","sources":["../../../../src/components/activity-indicator/index.ios.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AACnE,OAAO,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAC;AAC/D,OAAO,EAAE,qBAAqB,EAAE,MAAM,UAAU,CAAC;;AAGjD,MAAM,iBAAiB,GAAG,SAAS,CAAC;AASpC,MAAM,OAAO,iBAAkB,SAAQ,qBAAqB;IACvC,YAAY,GAAG,iBAAiB,CAAC;uGADzC,iBAAiB;2FAAjB,iBAAiB,oGAFlB,oDAAoD,4DAFpD,gBAAgB;;2FAIf,iBAAiB;kBAP7B,SAAS;mBAAC;oBACT,QAAQ,EAAE,mBAAmB;oBAC7B,UAAU,EAAE,IAAI;oBAChB,OAAO,EAAE,CAAC,gBAAgB,CAAC;oBAC3B,eAAe,EAAE,uBAAuB,CAAC,MAAM;oBAC/C,QAAQ,EAAE,oDAAoD;iBAC/D"}

package/build/angular/components/activity-indicator/index.js

@@ -0,0 +1,4 @@
+// Base/default ActivityIndicator. Re-exports the iOS build; Metro picks index.ios.ts /
+// index.android.ts in platform bundles.
+export * from './index.ios';
+//# sourceMappingURL=index.js.map

package/build/angular/components/activity-indicator/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/components/activity-indicator/index.ts"],"names":[],"mappings":"AAAA,uFAAuF;AACvF,wCAAwC;AAExC,cAAc,aAAa,CAAC"}