@ng-native/expo 0.0.1 → 0.1.0

package/dist/store-review.d.ts

@@ -0,0 +1,43 @@
+/**
+ * `StoreReview`, bound to `expo-store-review`: the platform's "rate this app" prompt.
+ *
+ * ```ts
+ * private readonly review = inject(StoreReview);
+ *
+ * async finishedFifthWorkout(): Promise<void> {
+ *   if (await this.review.hasAction()) await this.review.request();
+ * }
+ * ```
+ *
+ * The module's own four functions under shorter names. The prompt is the platform's, and so is the
+ * decision whether it appears at all: iOS shows it at most three times a year and says nothing
+ * when it declines, so a call that resolves is not a prompt that was shown. Without the module
+ * installed, every question answers no and `request()` does nothing.
+ */
+import { InjectionToken } from '@angular/core';
+import * as i0 from "@angular/core";
+type Expo = typeof import('expo-store-review');
+/** The module's functions this service calls. The real module is one; a test provides a fake. */
+export type NativeStoreReview = Pick<Expo, 'isAvailableAsync' | 'hasAction' | 'requestReview' | 'storeUrl'>;
+export declare class StoreReview {
+    /** Overridden in a test to ask for a review nobody will be shown. */
+    static readonly SOURCE: InjectionToken<NativeStoreReview | null>;
+    private readonly native;
+    /** Whether the platform has an in-app review prompt: iOS, and Android with the Play Store. */
+    available(): Promise<boolean>;
+    /**
+     * Whether `request()` would do anything: show the prompt, or failing that open the store page
+     * set as `ios.appStoreUrl` or `android.playStoreUrl` in the app config.
+     */
+    hasAction(): Promise<boolean>;
+    /**
+     * Asks the platform to show the prompt, or opens the store page where there is none. Resolves
+     * whether or not the platform chose to show anything.
+     */
+    request(): Promise<void>;
+    /** The app's store page from the app config, for a "rate us" link. Null when none is set. */
+    storeUrl(): string | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StoreReview, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+export {};

package/dist/store-review.js

@@ -0,0 +1,52 @@
+/**
+ * `StoreReview`, bound to `expo-store-review`: the platform's "rate this app" prompt.
+ *
+ * ```ts
+ * private readonly review = inject(StoreReview);
+ *
+ * async finishedFifthWorkout(): Promise<void> {
+ *   if (await this.review.hasAction()) await this.review.request();
+ * }
+ * ```
+ *
+ * The module's own four functions under shorter names. The prompt is the platform's, and so is the
+ * decision whether it appears at all: iOS shows it at most three times a year and says nothing
+ * when it declines, so a call that resolves is not a prompt that was shown. Without the module
+ * installed, every question answers no and `request()` does nothing.
+ */
+import { InjectionToken, Service, inject } from '@angular/core';
+import { expoModule } from "./native.js";
+import * as i0 from "@angular/core";
+export class StoreReview {
+    /** Overridden in a test to ask for a review nobody will be shown. */
+    static SOURCE = new InjectionToken('angular-native.storeReviewSource', { factory: () => expoModule('expo-store-review', () => require('expo-store-review')) });
+    native = inject(StoreReview.SOURCE);
+    /** Whether the platform has an in-app review prompt: iOS, and Android with the Play Store. */
+    async available() {
+        return (await this.native?.isAvailableAsync()) ?? false;
+    }
+    /**
+     * Whether `request()` would do anything: show the prompt, or failing that open the store page
+     * set as `ios.appStoreUrl` or `android.playStoreUrl` in the app config.
+     */
+    async hasAction() {
+        return (await this.native?.hasAction()) ?? false;
+    }
+    /**
+     * Asks the platform to show the prompt, or opens the store page where there is none. Resolves
+     * whether or not the platform chose to show anything.
+     */
+    async request() {
+        await this.native?.requestReview();
+    }
+    /** The app's store page from the app config, for a "rate us" link. Null when none is set. */
+    storeUrl() {
+        return this.native?.storeUrl() ?? null;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.2.0", ngImport: i0, type: StoreReview, deps: [], target: i0.ɵɵFactoryTarget.Service });
+    static ɵprov = i0.ɵɵngDeclareService({ minVersion: "22.0.0", version: "22.2.0", ngImport: i0, type: StoreReview });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.2.0", ngImport: i0, type: StoreReview, decorators: [{
+            type: Service
+        }] });
+//# sourceMappingURL=store-review.js.map

package/dist/store-review.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"store-review.js","sourceRoot":"","sources":["../src/store-review.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,OAAO,EAAE,cAAc,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAChE,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;;AAWzC,MAAM,OAAO,WAAW;IACtB,qEAAqE;IACrE,MAAM,CAAU,MAAM,GAAG,IAAI,cAAc,CACzC,kCAAkC,EAClC,EAAE,OAAO,EAAE,GAAG,EAAE,CAAC,UAAU,CAAC,mBAAmB,EAAE,GAAG,EAAE,CAAC,OAAO,CAAC,mBAAmB,CAAS,CAAC,EAAE,CAC/F,CAAC;IAEe,MAAM,GAAG,MAAM,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC;IAErD,8FAA8F;IAC9F,KAAK,CAAC,SAAS;QACb,OAAO,CAAC,MAAM,IAAI,CAAC,MAAM,EAAE,gBAAgB,EAAE,CAAC,IAAI,KAAK,CAAC;IAC1D,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,SAAS;QACb,OAAO,CAAC,MAAM,IAAI,CAAC,MAAM,EAAE,SAAS,EAAE,CAAC,IAAI,KAAK,CAAC;IACnD,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,OAAO;QACX,MAAM,IAAI,CAAC,MAAM,EAAE,aAAa,EAAE,CAAC;IACrC,CAAC;IAED,6FAA6F;IAC7F,QAAQ;QACN,OAAO,IAAI,CAAC,MAAM,EAAE,QAAQ,EAAE,IAAI,IAAI,CAAC;IACzC,CAAC;uGAjCU,WAAW;wGAAX,WAAW;;2FAAX,WAAW;kBADvB,OAAO","sourcesContent":["/**\n * `StoreReview`, bound to `expo-store-review`: the platform's \"rate this app\" prompt.\n *\n * ```ts\n * private readonly review = inject(StoreReview);\n *\n * async finishedFifthWorkout(): Promise<void> {\n *   if (await this.review.hasAction()) await this.review.request();\n * }\n * ```\n *\n * The module's own four functions under shorter names. The prompt is the platform's, and so is the\n * decision whether it appears at all: iOS shows it at most three times a year and says nothing\n * when it declines, so a call that resolves is not a prompt that was shown. Without the module\n * installed, every question answers no and `request()` does nothing.\n */\nimport { InjectionToken, Service, inject } from '@angular/core';\nimport { expoModule } from './native.ts';\n\ntype Expo = typeof import('expo-store-review');\n\n/** The module's functions this service calls. The real module is one; a test provides a fake. */\nexport type NativeStoreReview = Pick<\n  Expo,\n  'isAvailableAsync' | 'hasAction' | 'requestReview' | 'storeUrl'\n>;\n\n@Service()\nexport class StoreReview {\n  /** Overridden in a test to ask for a review nobody will be shown. */\n  static readonly SOURCE = new InjectionToken<NativeStoreReview | null>(\n    'angular-native.storeReviewSource',\n    { factory: () => expoModule('expo-store-review', () => require('expo-store-review') as Expo) },\n  );\n\n  private readonly native = inject(StoreReview.SOURCE);\n\n  /** Whether the platform has an in-app review prompt: iOS, and Android with the Play Store. */\n  async available(): Promise<boolean> {\n    return (await this.native?.isAvailableAsync()) ?? false;\n  }\n\n  /**\n   * Whether `request()` would do anything: show the prompt, or failing that open the store page\n   * set as `ios.appStoreUrl` or `android.playStoreUrl` in the app config.\n   */\n  async hasAction(): Promise<boolean> {\n    return (await this.native?.hasAction()) ?? false;\n  }\n\n  /**\n   * Asks the platform to show the prompt, or opens the store page where there is none. Resolves\n   * whether or not the platform chose to show anything.\n   */\n  async request(): Promise<void> {\n    await this.native?.requestReview();\n  }\n\n  /** The app's store page from the app config, for a \"rate us\" link. Null when none is set. */\n  storeUrl(): string | null {\n    return this.native?.storeUrl() ?? null;\n  }\n}\n"]}

package/dist/store.d.ts

@@ -0,0 +1,108 @@
+/**
+ * `Storage` and `SecureStorage`, bound to `@react-native-async-storage/async-storage` and
+ * `expo-secure-store`.
+ *
+ * ```ts
+ * private readonly store = inject(Storage);
+ * protected readonly theme = this.store.signal<'light' | 'dark'>('theme', 'light');
+ * ```
+ *
+ * The signal is bound both ways: reading it is reading the preference, setting it persists.
+ *
+ * The underlying APIs are already plain promises with no React in them, so what is built is not a
+ * wrapper but a *binding*: `store.signal('theme', 'light')` reads it back once, writes it through
+ * whenever it is set, and is an ordinary signal in between. Everything is JSON, because both
+ * stores hold strings and a store that silently held `"[object Object]"` would be worse than one
+ * that held nothing.
+ *
+ * Two services rather than one because the difference matters and should be visible at the
+ * injection site. `SecureStorage` is the keychain and the Android keystore: small values, an
+ * async write, and a size limit that is not documented but is real. `Storage` is a plain
+ * key-value file: bigger, faster, and readable by anyone with the device unlocked. Two tokens
+ * over one class, for the same reason the sensors are.
+ */
+import { InjectionToken, type Signal, type WritableSignal } from '@angular/core';
+/** What both `AsyncStorage` and `SecureStore` offer, reduced to the three verbs. */
+export interface NativeStore {
+    get(key: string): Promise<string | null>;
+    set(key: string, value: string): Promise<void>;
+    remove(key: string): Promise<void>;
+    /** Where the platform can answer without waiting - `SecureStore` can, `AsyncStorage` cannot. */
+    getSync?(key: string): string | null;
+}
+export declare class Store {
+    private readonly native;
+    private readonly bound;
+    /** Keys written by the app before their read came back. The read must not undo a write. */
+    private readonly written;
+    /**
+     * Updates made to a key whose read has not come back, in order. An update changes the stored
+     * value rather than replacing it, so these wait for it and are applied to it, not to `initial`.
+     */
+    private readonly waiting;
+    /** Reads started and not yet back, successful or not. */
+    private readonly reading;
+    private readonly failure;
+    /** Writes sent to the platform and not yet answered. What `flush()` waits for. */
+    private readonly writes;
+    /** The first write to fail since the last `flush()`, held until a flush reports it. */
+    private unreported;
+    constructor(native: NativeStore | null);
+    /**
+     * Whether every key asked for so far has been read back. False while any read is outstanding,
+     * so it goes back to false when a new key is asked for, and true again once that read returns.
+     *
+     * A read that fails still counts as back: the signal keeps its `initial`, and the failure is on
+     * `error`. A loading screen held on `ready` should not wait forever for a store that is broken.
+     */
+    readonly ready: Signal<boolean>;
+    /**
+     * The most recent read or write that failed, or null while none has.
+     *
+     * A write through `set()` has no promise to reject, so this is where a full disk or a locked
+     * keychain is reported. `flush()` is the way to wait on the writes themselves.
+     */
+    readonly error: Signal<Error | null>;
+    /**
+     * The stored value at `key`, as a signal that writes through when set.
+     *
+     * Starts at `initial` and stays there until the read returns, which is one turn away at best -
+     * unless the platform can answer synchronously, in which case it never shows `initial` at all.
+     * The same key always returns the same signal, so two components binding to it stay in step.
+     */
+    signal<T>(key: string, initial: T): WritableSignal<T>;
+    /**
+     * Forget a key, in the store and in the signal bound to it.
+     *
+     * The signal goes back to the `initial` it was first asked for with, and stays the one signal
+     * for the key. Rejects if the platform could not remove it, which also sets `error`.
+     */
+    remove(key: string): Promise<void>;
+    /**
+     * Wait for every write sent so far. Rejects with the first of them that failed since the last
+     * `flush()`, whether it failed before this call or while waiting, so a screen that has to know a
+     * value reached the disk - before signing out, say - can find out. Each failure is reported by
+     * one flush only.
+     */
+    flush(): Promise<void>;
+    private readSync;
+    /**
+     * Read the stored value in, unless the app has already set one.
+     *
+     * The race is real and silent: a screen that writes a preference during startup would otherwise
+     * have it overwritten a tick later by whatever was there before.
+     */
+    private hydrate;
+    /** The read is back: show what was stored, with any updates that waited for it applied. */
+    private settle;
+    private write;
+    /** A platform call, kept until it answers, with its failure reported on `error`. */
+    private track;
+    private fail;
+}
+/** A plain key-value file. Bigger and faster than the keychain, and not private. */
+export declare const Storage: InjectionToken<Store>;
+export type Storage = Store;
+/** The keychain and the Android keystore. Small values, and worth the size limit. */
+export declare const SecureStorage: InjectionToken<Store>;
+export type SecureStorage = Store;

package/dist/store.js

@@ -0,0 +1,247 @@
+/**
+ * `Storage` and `SecureStorage`, bound to `@react-native-async-storage/async-storage` and
+ * `expo-secure-store`.
+ *
+ * ```ts
+ * private readonly store = inject(Storage);
+ * protected readonly theme = this.store.signal<'light' | 'dark'>('theme', 'light');
+ * ```
+ *
+ * The signal is bound both ways: reading it is reading the preference, setting it persists.
+ *
+ * The underlying APIs are already plain promises with no React in them, so what is built is not a
+ * wrapper but a *binding*: `store.signal('theme', 'light')` reads it back once, writes it through
+ * whenever it is set, and is an ordinary signal in between. Everything is JSON, because both
+ * stores hold strings and a store that silently held `"[object Object]"` would be worse than one
+ * that held nothing.
+ *
+ * Two services rather than one because the difference matters and should be visible at the
+ * injection site. `SecureStorage` is the keychain and the Android keystore: small values, an
+ * async write, and a size limit that is not documented but is real. `Storage` is a plain
+ * key-value file: bigger, faster, and readable by anyone with the device unlocked. Two tokens
+ * over one class, for the same reason the sensors are.
+ */
+import { InjectionToken, computed, signal } from '@angular/core';
+import { expoModule } from "./native.js";
+export class Store {
+    native;
+    bound = new Map();
+    /** Keys written by the app before their read came back. The read must not undo a write. */
+    written = new Set();
+    /**
+     * Updates made to a key whose read has not come back, in order. An update changes the stored
+     * value rather than replacing it, so these wait for it and are applied to it, not to `initial`.
+     */
+    waiting = new Map();
+    /** Reads started and not yet back, successful or not. */
+    reading = signal(0, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "reading" }] : /* istanbul ignore next */ []));
+    failure = signal(null, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "failure" }] : /* istanbul ignore next */ []));
+    /** Writes sent to the platform and not yet answered. What `flush()` waits for. */
+    writes = new Set();
+    /** The first write to fail since the last `flush()`, held until a flush reports it. */
+    unreported = null;
+    constructor(native) {
+        this.native = native;
+    }
+    /**
+     * Whether every key asked for so far has been read back. False while any read is outstanding,
+     * so it goes back to false when a new key is asked for, and true again once that read returns.
+     *
+     * A read that fails still counts as back: the signal keeps its `initial`, and the failure is on
+     * `error`. A loading screen held on `ready` should not wait forever for a store that is broken.
+     */
+    ready = computed(() => this.reading() === 0, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "ready" }] : /* istanbul ignore next */ []));
+    /**
+     * The most recent read or write that failed, or null while none has.
+     *
+     * A write through `set()` has no promise to reject, so this is where a full disk or a locked
+     * keychain is reported. `flush()` is the way to wait on the writes themselves.
+     */
+    error = this.failure.asReadonly();
+    /**
+     * The stored value at `key`, as a signal that writes through when set.
+     *
+     * Starts at `initial` and stays there until the read returns, which is one turn away at best -
+     * unless the platform can answer synchronously, in which case it never shows `initial` at all.
+     * The same key always returns the same signal, so two components binding to it stay in step.
+     */
+    signal(key, initial) {
+        const existing = this.bound.get(key);
+        if (existing)
+            return existing.value;
+        const stored = this.readSync(key);
+        const value = signal(stored === ABSENT ? initial : stored, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "value" }] : /* istanbul ignore next */ []));
+        const set = value.set.bind(value);
+        const update = value.update.bind(value);
+        value.set = (next) => {
+            this.written.add(key);
+            this.waiting.delete(key);
+            set(next);
+            this.write(key, next);
+        };
+        value.update = (fn) => {
+            // Shown at once, on what is known so far, and written once the stored value is known.
+            const waiting = this.waiting.get(key);
+            update(fn);
+            if (waiting) {
+                waiting.push(fn);
+                return;
+            }
+            this.written.add(key);
+            this.write(key, value());
+        };
+        this.bound.set(key, {
+            value: value,
+            reset: set,
+            initial,
+        });
+        // A platform that answered synchronously has said what is stored; one that cannot has not.
+        if (stored === ABSENT && this.native && !this.native.getSync)
+            this.waiting.set(key, []);
+        void this.hydrate(key, set, initial);
+        return value;
+    }
+    /**
+     * Forget a key, in the store and in the signal bound to it.
+     *
+     * The signal goes back to the `initial` it was first asked for with, and stays the one signal
+     * for the key. Rejects if the platform could not remove it, which also sets `error`.
+     */
+    async remove(key) {
+        this.written.add(key);
+        this.waiting.delete(key);
+        const binding = this.bound.get(key);
+        binding?.reset(binding.initial);
+        await this.track(this.native?.remove(key));
+    }
+    /**
+     * Wait for every write sent so far. Rejects with the first of them that failed since the last
+     * `flush()`, whether it failed before this call or while waiting, so a screen that has to know a
+     * value reached the disk - before signing out, say - can find out. Each failure is reported by
+     * one flush only.
+     */
+    async flush() {
+        await Promise.allSettled([...this.writes]);
+        const failed = this.unreported;
+        this.unreported = null;
+        if (failed)
+            throw failed.error;
+    }
+    readSync(key) {
+        const raw = this.native?.getSync?.(key);
+        return raw == null ? ABSENT : decode(raw);
+    }
+    /**
+     * Read the stored value in, unless the app has already set one.
+     *
+     * The race is real and silent: a screen that writes a preference during startup would otherwise
+     * have it overwritten a tick later by whatever was there before.
+     */
+    async hydrate(key, set, initial) {
+        this.reading.update((n) => n + 1);
+        let stored = ABSENT;
+        try {
+            const raw = await this.native?.get(key);
+            if (raw != null)
+                stored = decode(raw);
+        }
+        catch (error) {
+            this.fail(error);
+        }
+        finally {
+            this.settle(key, set, stored === ABSENT ? initial : stored, stored !== ABSENT);
+            this.reading.update((n) => n - 1);
+        }
+    }
+    /** The read is back: show what was stored, with any updates that waited for it applied. */
+    settle(key, set, base, found) {
+        const updates = this.waiting.get(key);
+        this.waiting.delete(key);
+        if (this.written.has(key))
+            return;
+        if (!updates?.length) {
+            if (found)
+                set(base);
+            return;
+        }
+        const value = updates.reduce((current, fn) => fn(current), base);
+        this.written.add(key);
+        set(value);
+        this.write(key, value);
+    }
+    write(key, value) {
+        const sent = value === undefined ? this.native?.remove(key) : this.native?.set(key, JSON.stringify(value));
+        // Observed here, so a failure lands on `error` and in `flush()` rather than going unhandled.
+        this.track(sent).catch(() => { });
+    }
+    /** A platform call, kept until it answers, with its failure reported on `error`. */
+    track(sent) {
+        if (!sent)
+            return Promise.resolve();
+        const tracked = sent.then(() => undefined, (error) => {
+            this.fail(error);
+            this.unreported ??= { error };
+            throw error;
+        });
+        this.writes.add(tracked);
+        const forget = () => void this.writes.delete(tracked);
+        tracked.then(forget, forget);
+        return tracked;
+    }
+    fail(error) {
+        this.failure.set(error instanceof Error ? error : new Error(String(error)));
+    }
+}
+/** What `decode` answers for a string that is not JSON, since `null` is a value JSON can hold. */
+const ABSENT = Symbol('absent');
+/**
+ * A stored string as the value it encodes.
+ *
+ * A value that will not parse is treated as absent rather than thrown: it is a store written by
+ * an older version of the app, and the right answer is the default the caller already supplied.
+ * A stored `null` is not that: it parses, and a nullable signal gets it back.
+ */
+function decode(raw) {
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return ABSENT;
+    }
+}
+const plain = () => {
+    const module = expoModule('@react-native-async-storage/async-storage', () => require('@react-native-async-storage/async-storage'));
+    const store = module?.default;
+    if (!store)
+        return null;
+    return {
+        get: (key) => store.getItem(key),
+        set: (key, value) => store.setItem(key, value),
+        remove: (key) => store.removeItem(key),
+    };
+};
+const secure = () => {
+    const expo = expoModule('expo-secure-store', () => require('expo-secure-store'));
+    if (!expo)
+        return null;
+    return {
+        get: (key) => expo.getItemAsync(key),
+        set: (key, value) => expo.setItemAsync(key, value),
+        remove: (key) => expo.deleteItemAsync(key),
+        // The keychain can answer without waiting, so a token never flashes its default.
+        getSync: (key) => expo.getItem(key),
+    };
+};
+/** A plain key-value file. Bigger and faster than the keychain, and not private. */
+export const Storage = new InjectionToken('angular-native.storage', {
+    factory: () => new Store(plain()),
+});
+/** The keychain and the Android keystore. Small values, and worth the size limit. */
+export const SecureStorage = new InjectionToken('angular-native.secureStorage', {
+    factory: () => new Store(secure()),
+});
+//# sourceMappingURL=store.js.map

package/dist/store.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"store.js","sourceRoot":"","sources":["../src/store.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * `Storage` and `SecureStorage`, bound to `@react-native-async-storage/async-storage` and\n * `expo-secure-store`.\n *\n * ```ts\n * private readonly store = inject(Storage);\n * protected readonly theme = this.store.signal<'light' | 'dark'>('theme', 'light');\n * ```\n *\n * The signal is bound both ways: reading it is reading the preference, setting it persists.\n *\n * The underlying APIs are already plain promises with no React in them, so what is built is not a\n * wrapper but a *binding*: `store.signal('theme', 'light')` reads it back once, writes it through\n * whenever it is set, and is an ordinary signal in between. Everything is JSON, because both\n * stores hold strings and a store that silently held `\"[object Object]\"` would be worse than one\n * that held nothing.\n *\n * Two services rather than one because the difference matters and should be visible at the\n * injection site. `SecureStorage` is the keychain and the Android keystore: small values, an\n * async write, and a size limit that is not documented but is real. `Storage` is a plain\n * key-value file: bigger, faster, and readable by anyone with the device unlocked. Two tokens\n * over one class, for the same reason the sensors are.\n */\nimport { InjectionToken, computed, signal, type Signal, type WritableSignal } from '@angular/core';\nimport { expoModule } from './native.ts';\n\n/** What both `AsyncStorage` and `SecureStore` offer, reduced to the three verbs. */\nexport interface NativeStore {\n  get(key: string): Promise<string | null>;\n  set(key: string, value: string): Promise<void>;\n  remove(key: string): Promise<void>;\n  /** Where the platform can answer without waiting - `SecureStore` can, `AsyncStorage` cannot. */\n  getSync?(key: string): string | null;\n}\n\n/** A key's signal, with what `remove()` needs to put it back. */\ninterface Binding {\n  readonly value: WritableSignal<unknown>;\n  /** The signal's own `set`, which does not write through. */\n  readonly reset: (value: unknown) => void;\n  readonly initial: unknown;\n}\n\nexport class Store {\n  private readonly native: NativeStore | null;\n  private readonly bound = new Map<string, Binding>();\n  /** Keys written by the app before their read came back. The read must not undo a write. */\n  private readonly written = new Set<string>();\n  /**\n   * Updates made to a key whose read has not come back, in order. An update changes the stored\n   * value rather than replacing it, so these wait for it and are applied to it, not to `initial`.\n   */\n  private readonly waiting = new Map<string, ((current: unknown) => unknown)[]>();\n  /** Reads started and not yet back, successful or not. */\n  private readonly reading = signal(0);\n  private readonly failure = signal<Error | null>(null);\n  /** Writes sent to the platform and not yet answered. What `flush()` waits for. */\n  private readonly writes = new Set<Promise<void>>();\n  /** The first write to fail since the last `flush()`, held until a flush reports it. */\n  private unreported: { readonly error: unknown } | null = null;\n\n  constructor(native: NativeStore | null) {\n    this.native = native;\n  }\n\n  /**\n   * Whether every key asked for so far has been read back. False while any read is outstanding,\n   * so it goes back to false when a new key is asked for, and true again once that read returns.\n   *\n   * A read that fails still counts as back: the signal keeps its `initial`, and the failure is on\n   * `error`. A loading screen held on `ready` should not wait forever for a store that is broken.\n   */\n  readonly ready: Signal<boolean> = computed(() => this.reading() === 0);\n\n  /**\n   * The most recent read or write that failed, or null while none has.\n   *\n   * A write through `set()` has no promise to reject, so this is where a full disk or a locked\n   * keychain is reported. `flush()` is the way to wait on the writes themselves.\n   */\n  readonly error: Signal<Error | null> = this.failure.asReadonly();\n\n  /**\n   * The stored value at `key`, as a signal that writes through when set.\n   *\n   * Starts at `initial` and stays there until the read returns, which is one turn away at best -\n   * unless the platform can answer synchronously, in which case it never shows `initial` at all.\n   * The same key always returns the same signal, so two components binding to it stay in step.\n   */\n  signal<T>(key: string, initial: T): WritableSignal<T> {\n    const existing = this.bound.get(key);\n    if (existing) return existing.value as WritableSignal<T>;\n\n    const stored = this.readSync(key);\n    const value = signal<T>(stored === ABSENT ? initial : (stored as T));\n\n    const set = value.set.bind(value);\n    const update = value.update.bind(value);\n    value.set = (next: T) => {\n      this.written.add(key);\n      this.waiting.delete(key);\n      set(next);\n      this.write(key, next);\n    };\n    value.update = (fn: (current: T) => T) => {\n      // Shown at once, on what is known so far, and written once the stored value is known.\n      const waiting = this.waiting.get(key);\n      update(fn);\n      if (waiting) {\n        waiting.push(fn as (current: unknown) => unknown);\n        return;\n      }\n      this.written.add(key);\n      this.write(key, value());\n    };\n    this.bound.set(key, {\n      value: value as WritableSignal<unknown>,\n      reset: set as (value: unknown) => void,\n      initial,\n    });\n\n    // A platform that answered synchronously has said what is stored; one that cannot has not.\n    if (stored === ABSENT && this.native && !this.native.getSync) this.waiting.set(key, []);\n    void this.hydrate(key, set, initial);\n    return value;\n  }\n\n  /**\n   * Forget a key, in the store and in the signal bound to it.\n   *\n   * The signal goes back to the `initial` it was first asked for with, and stays the one signal\n   * for the key. Rejects if the platform could not remove it, which also sets `error`.\n   */\n  async remove(key: string): Promise<void> {\n    this.written.add(key);\n    this.waiting.delete(key);\n    const binding = this.bound.get(key);\n    binding?.reset(binding.initial);\n    await this.track(this.native?.remove(key));\n  }\n\n  /**\n   * Wait for every write sent so far. Rejects with the first of them that failed since the last\n   * `flush()`, whether it failed before this call or while waiting, so a screen that has to know a\n   * value reached the disk - before signing out, say - can find out. Each failure is reported by\n   * one flush only.\n   */\n  async flush(): Promise<void> {\n    await Promise.allSettled([...this.writes]);\n    const failed = this.unreported;\n    this.unreported = null;\n    if (failed) throw failed.error;\n  }\n\n  private readSync(key: string): unknown {\n    const raw = this.native?.getSync?.(key);\n    return raw == null ? ABSENT : decode(raw);\n  }\n\n  /**\n   * Read the stored value in, unless the app has already set one.\n   *\n   * The race is real and silent: a screen that writes a preference during startup would otherwise\n   * have it overwritten a tick later by whatever was there before.\n   */\n  private async hydrate<T>(key: string, set: (value: T) => void, initial: T): Promise<void> {\n    this.reading.update((n) => n + 1);\n    let stored: unknown = ABSENT;\n    try {\n      const raw = await this.native?.get(key);\n      if (raw != null) stored = decode(raw);\n    } catch (error) {\n      this.fail(error);\n    } finally {\n      this.settle(key, set, stored === ABSENT ? initial : stored, stored !== ABSENT);\n      this.reading.update((n) => n - 1);\n    }\n  }\n\n  /** The read is back: show what was stored, with any updates that waited for it applied. */\n  private settle<T>(key: string, set: (value: T) => void, base: unknown, found: boolean): void {\n    const updates = this.waiting.get(key);\n    this.waiting.delete(key);\n    if (this.written.has(key)) return;\n    if (!updates?.length) {\n      if (found) set(base as T);\n      return;\n    }\n    const value = updates.reduce((current, fn) => fn(current), base);\n    this.written.add(key);\n    set(value as T);\n    this.write(key, value);\n  }\n\n  private write(key: string, value: unknown): void {\n    const sent =\n      value === undefined ? this.native?.remove(key) : this.native?.set(key, JSON.stringify(value));\n    // Observed here, so a failure lands on `error` and in `flush()` rather than going unhandled.\n    this.track(sent).catch(() => {});\n  }\n\n  /** A platform call, kept until it answers, with its failure reported on `error`. */\n  private track(sent: Promise<void> | undefined): Promise<void> {\n    if (!sent) return Promise.resolve();\n    const tracked = sent.then(\n      () => undefined,\n      (error: unknown) => {\n        this.fail(error);\n        this.unreported ??= { error };\n        throw error;\n      },\n    );\n    this.writes.add(tracked);\n    const forget = () => void this.writes.delete(tracked);\n    tracked.then(forget, forget);\n    return tracked;\n  }\n\n  private fail(error: unknown): void {\n    this.failure.set(error instanceof Error ? error : new Error(String(error)));\n  }\n}\n\n/** What `decode` answers for a string that is not JSON, since `null` is a value JSON can hold. */\nconst ABSENT: unique symbol = Symbol('absent');\n\n/**\n * A stored string as the value it encodes.\n *\n * A value that will not parse is treated as absent rather than thrown: it is a store written by\n * an older version of the app, and the right answer is the default the caller already supplied.\n * A stored `null` is not that: it parses, and a nullable signal gets it back.\n */\nfunction decode(raw: string): unknown {\n  try {\n    return JSON.parse(raw) as unknown;\n  } catch {\n    return ABSENT;\n  }\n}\n\nconst plain = (): NativeStore | null => {\n  const module = expoModule(\n    '@react-native-async-storage/async-storage',\n    () =>\n      require('@react-native-async-storage/async-storage') as {\n        default: typeof import('@react-native-async-storage/async-storage').default;\n      },\n  );\n  const store = module?.default;\n  if (!store) return null;\n  return {\n    get: (key) => store.getItem(key),\n    set: (key, value) => store.setItem(key, value),\n    remove: (key) => store.removeItem(key),\n  };\n};\n\nconst secure = (): NativeStore | null => {\n  const expo = expoModule(\n    'expo-secure-store',\n    () => require('expo-secure-store') as typeof import('expo-secure-store'),\n  );\n  if (!expo) return null;\n  return {\n    get: (key) => expo.getItemAsync(key),\n    set: (key, value) => expo.setItemAsync(key, value),\n    remove: (key) => expo.deleteItemAsync(key),\n    // The keychain can answer without waiting, so a token never flashes its default.\n    getSync: (key) => expo.getItem(key),\n  };\n};\n\n/** A plain key-value file. Bigger and faster than the keychain, and not private. */\nexport const Storage = new InjectionToken<Store>('angular-native.storage', {\n  factory: () => new Store(plain()),\n});\nexport type Storage = Store;\n\n/** The keychain and the Android keystore. Small values, and worth the size limit. */\nexport const SecureStorage = new InjectionToken<Store>('angular-native.secureStorage', {\n  factory: () => new Store(secure()),\n});\nexport type SecureStorage = Store;\n"]}

package/dist/symbol.d.ts

@@ -0,0 +1,36 @@
+import * as i0 from "@angular/core";
+export type SymbolType = 'monochrome' | 'hierarchical' | 'palette' | 'multicolor';
+export type SymbolScale = 'default' | 'unspecified' | 'small' | 'medium' | 'large';
+export type SymbolWeight = 'unspecified' | 'ultraLight' | 'thin' | 'light' | 'regular' | 'medium' | 'semibold' | 'bold' | 'heavy' | 'black';
+export type SymbolResizeMode = 'scaleToFill' | 'scaleAspectFit' | 'scaleAspectFill' | 'redraw' | 'center' | 'top' | 'bottom' | 'left' | 'right' | 'topLeft' | 'topRight' | 'bottomLeft' | 'bottomRight';
+/** How a symbol animates, as `expo-symbols` describes it. */
+export interface SymbolAnimationSpec {
+    readonly effect?: {
+        readonly type: 'bounce' | 'pulse' | 'scale';
+        readonly wholeSymbol?: boolean;
+        readonly direction?: 'up' | 'down';
+    };
+    readonly repeating?: boolean;
+    readonly repeatCount?: number;
+    readonly speed?: number;
+    readonly variableAnimationSpec?: Readonly<Record<string, boolean>>;
+}
+export declare class ExpoSymbol {
+    /** The symbol's name, as SF Symbols lists it: `heart.fill`, `cloud.sun.rain`. */
+    readonly name: import("@angular/core").InputSignal<string>;
+    readonly type: import("@angular/core").InputSignal<SymbolType>;
+    readonly scale: import("@angular/core").InputSignal<SymbolScale | undefined>;
+    readonly weight: import("@angular/core").InputSignal<SymbolWeight | undefined>;
+    /** The colour of a `monochrome` or `hierarchical` symbol. */
+    readonly tintColor: import("@angular/core").InputSignal<string | undefined>;
+    /** The layers' colours, for `palette`. */
+    readonly colors: import("@angular/core").InputSignal<string | readonly string[] | undefined>;
+    readonly resizeMode: import("@angular/core").InputSignal<SymbolResizeMode | undefined>;
+    readonly animationSpec: import("@angular/core").InputSignal<SymbolAnimationSpec | undefined>;
+    /** Points, both ways. */
+    readonly size: import("@angular/core").InputSignalWithTransform<number, unknown>;
+    protected readonly colourList: import("@angular/core").Signal<readonly string[] | undefined>;
+    protected readonly animated: import("@angular/core").Signal<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ExpoSymbol, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ExpoSymbol, "expo-symbol", never, { "name": { "alias": "name"; "required": true; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; "scale": { "alias": "scale"; "required": false; "isSignal": true; }; "weight": { "alias": "weight"; "required": false; "isSignal": true; }; "tintColor": { "alias": "tintColor"; "required": false; "isSignal": true; }; "colors": { "alias": "colors"; "required": false; "isSignal": true; }; "resizeMode": { "alias": "resizeMode"; "required": false; "isSignal": true; }; "animationSpec": { "alias": "animationSpec"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/dist/symbol.js

@@ -0,0 +1,69 @@
+/**
+ * `<expo-symbol>`: an SF Symbol, from `expo-symbols`, typed so a template is checked against the
+ * props. iOS only. Registered with `registerExpoViews('expo-symbol')`.
+ *
+ * It does what the module's React component does before native sees the props: the view is `size`
+ * points square (24 unless set), `type` is `monochrome` unless set, one colour or several become
+ * the list native takes, and an `animationSpec` is what turns animation on.
+ *
+ * ```html
+ * <expo-symbol name="heart.fill" [size]="28" tintColor="#ff2d55" weight="semibold" />
+ * <expo-symbol name="cloud.sun.fill" type="palette" [colors]="['#fff', '#ffcc00']" />
+ * ```
+ */
+import { Component, computed, input } from '@angular/core';
+import { optionalNumber } from "./transforms.js";
+import * as i0 from "@angular/core";
+export class ExpoSymbol {
+    /** The symbol's name, as SF Symbols lists it: `heart.fill`, `cloud.sun.rain`. */
+    name = input.required(/* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "name" }] : /* istanbul ignore next */ []));
+    type = input('monochrome', /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "type" }] : /* istanbul ignore next */ []));
+    scale = input(/* @ts-ignore */
+    ...(ngDevMode ? [undefined, { debugName: "scale" }] : /* istanbul ignore next */ []));
+    weight = input(/* @ts-ignore */
+    ...(ngDevMode ? [undefined, { debugName: "weight" }] : /* istanbul ignore next */ []));
+    /** The colour of a `monochrome` or `hierarchical` symbol. */
+    tintColor = input(/* @ts-ignore */
+    ...(ngDevMode ? [undefined, { debugName: "tintColor" }] : /* istanbul ignore next */ []));
+    /** The layers' colours, for `palette`. */
+    colors = input(/* @ts-ignore */
+    ...(ngDevMode ? [undefined, { debugName: "colors" }] : /* istanbul ignore next */ []));
+    resizeMode = input(/* @ts-ignore */
+    ...(ngDevMode ? [undefined, { debugName: "resizeMode" }] : /* istanbul ignore next */ []));
+    animationSpec = input(/* @ts-ignore */
+    ...(ngDevMode ? [undefined, { debugName: "animationSpec" }] : /* istanbul ignore next */ []));
+    /** Points, both ways. */
+    size = input(24, { ...(ngDevMode ? { debugName: "size" } : /* istanbul ignore next */ {}), transform: (value) => optionalNumber(value) ?? 24 });
+    colourList = computed(() => {
+        const colours = this.colors();
+        return colours === undefined ? undefined : typeof colours === 'string' ? [colours] : colours;
+    }, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "colourList" }] : /* istanbul ignore next */ []));
+    animated = computed(() => this.animationSpec() !== undefined, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "animated" }] : /* istanbul ignore next */ []));
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.2.0", ngImport: i0, type: ExpoSymbol, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "22.2.0", type: ExpoSymbol, isStandalone: true, selector: "expo-symbol", inputs: { name: { classPropertyName: "name", publicName: "name", isSignal: true, isRequired: true, transformFunction: null }, type: { classPropertyName: "type", publicName: "type", isSignal: true, isRequired: false, transformFunction: null }, scale: { classPropertyName: "scale", publicName: "scale", isSignal: true, isRequired: false, transformFunction: null }, weight: { classPropertyName: "weight", publicName: "weight", isSignal: true, isRequired: false, transformFunction: null }, tintColor: { classPropertyName: "tintColor", publicName: "tintColor", isSignal: true, isRequired: false, transformFunction: null }, colors: { classPropertyName: "colors", publicName: "colors", isSignal: true, isRequired: false, transformFunction: null }, resizeMode: { classPropertyName: "resizeMode", publicName: "resizeMode", isSignal: true, isRequired: false, transformFunction: null }, animationSpec: { classPropertyName: "animationSpec", publicName: "animationSpec", isSignal: true, isRequired: false, transformFunction: null }, size: { classPropertyName: "size", publicName: "size", isSignal: true, isRequired: false, transformFunction: null } }, host: { properties: { "name": "name()", "type": "type()", "scale": "scale()", "weight": "weight()", "tintColor": "tintColor()", "colors": "colourList()", "resizeMode": "resizeMode()", "animationSpec": "animationSpec()", "animated": "animated()", "style.width": "size()", "style.height": "size()" } }, ngImport: i0, template: '', isInline: true });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.2.0", ngImport: i0, type: ExpoSymbol, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'expo-symbol',
+                    template: '',
+                    host: {
+                        '[name]': 'name()',
+                        '[type]': 'type()',
+                        '[scale]': 'scale()',
+                        '[weight]': 'weight()',
+                        '[tintColor]': 'tintColor()',
+                        '[colors]': 'colourList()',
+                        '[resizeMode]': 'resizeMode()',
+                        '[animationSpec]': 'animationSpec()',
+                        '[animated]': 'animated()',
+                        '[style.width]': 'size()',
+                        '[style.height]': 'size()',
+                    },
+                }]
+        }], propDecorators: { name: [{ type: i0.Input, args: [{ isSignal: true, alias: "name", required: true }] }], type: [{ type: i0.Input, args: [{ isSignal: true, alias: "type", required: false }] }], scale: [{ type: i0.Input, args: [{ isSignal: true, alias: "scale", required: false }] }], weight: [{ type: i0.Input, args: [{ isSignal: true, alias: "weight", required: false }] }], tintColor: [{ type: i0.Input, args: [{ isSignal: true, alias: "tintColor", required: false }] }], colors: [{ type: i0.Input, args: [{ isSignal: true, alias: "colors", required: false }] }], resizeMode: [{ type: i0.Input, args: [{ isSignal: true, alias: "resizeMode", required: false }] }], animationSpec: [{ type: i0.Input, args: [{ isSignal: true, alias: "animationSpec", required: false }] }], size: [{ type: i0.Input, args: [{ isSignal: true, alias: "size", required: false }] }] } });
+//# sourceMappingURL=symbol.js.map

package/dist/symbol.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"symbol.js","sourceRoot":"","sources":["../src/symbol.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AAC3D,OAAO,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;;AA4DjD,MAAM,OAAO,UAAU;IACrB,iFAAiF;IACxE,IAAI,GAAG,KAAK,CAAC,QAAQ;6EAAU,CAAC;IAChC,IAAI,GAAG,KAAK,CAAa,YAAY;6EAAC,CAAC;IACvC,KAAK,GAAG,KAAK;yFAAe,CAAC;IAC7B,MAAM,GAAG,KAAK;0FAAgB,CAAC;IACxC,6DAA6D;IACpD,SAAS,GAAG,KAAK;6FAAU,CAAC;IACrC,0CAA0C;IACjC,MAAM,GAAG,KAAK;0FAA8B,CAAC;IAC7C,UAAU,GAAG,KAAK;8FAAoB,CAAC;IACvC,aAAa,GAAG,KAAK;iGAAuB,CAAC;IACtD,yBAAyB;IAChB,IAAI,GAAG,KAAK,CAAC,EAAE,4EAAI,SAAS,EAAE,CAAC,KAAc,EAAE,EAAE,CAAC,cAAc,CAAC,KAAK,CAAC,IAAI,EAAE,GAAG,CAAC;IAEvE,UAAU,GAAG,QAAQ,CAAC,GAAG,EAAE;QAC5C,MAAM,OAAO,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC;QAC9B,OAAO,OAAO,KAAK,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,OAAO,OAAO,KAAK,QAAQ,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC;IAC/F,CAAC;mFAAC,CAAC;IACgB,QAAQ,GAAG,QAAQ,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,aAAa,EAAE,KAAK,SAAS;iFAAC,CAAC;uGAnBtE,UAAU;2FAAV,UAAU,u+CAfX,EAAE;;2FAeD,UAAU;kBAjBtB,SAAS;mBAAC;oBACT,QAAQ,EAAE,aAAa;oBACvB,QAAQ,EAAE,EAAE;oBACZ,IAAI,EAAE;wBACJ,QAAQ,EAAE,QAAQ;wBAClB,QAAQ,EAAE,QAAQ;wBAClB,SAAS,EAAE,SAAS;wBACpB,UAAU,EAAE,UAAU;wBACtB,aAAa,EAAE,aAAa;wBAC5B,UAAU,EAAE,cAAc;wBAC1B,cAAc,EAAE,cAAc;wBAC9B,iBAAiB,EAAE,iBAAiB;wBACpC,YAAY,EAAE,YAAY;wBAC1B,eAAe,EAAE,QAAQ;wBACzB,gBAAgB,EAAE,QAAQ;qBAC3B;iBACF","sourcesContent":["/**\n * `<expo-symbol>`: an SF Symbol, from `expo-symbols`, typed so a template is checked against the\n * props. iOS only. Registered with `registerExpoViews('expo-symbol')`.\n *\n * It does what the module's React component does before native sees the props: the view is `size`\n * points square (24 unless set), `type` is `monochrome` unless set, one colour or several become\n * the list native takes, and an `animationSpec` is what turns animation on.\n *\n * ```html\n * <expo-symbol name=\"heart.fill\" [size]=\"28\" tintColor=\"#ff2d55\" weight=\"semibold\" />\n * <expo-symbol name=\"cloud.sun.fill\" type=\"palette\" [colors]=\"['#fff', '#ffcc00']\" />\n * ```\n */\nimport { Component, computed, input } from '@angular/core';\nimport { optionalNumber } from './transforms.ts';\n\nexport type SymbolType = 'monochrome' | 'hierarchical' | 'palette' | 'multicolor';\nexport type SymbolScale = 'default' | 'unspecified' | 'small' | 'medium' | 'large';\nexport type SymbolWeight =\n  | 'unspecified'\n  | 'ultraLight'\n  | 'thin'\n  | 'light'\n  | 'regular'\n  | 'medium'\n  | 'semibold'\n  | 'bold'\n  | 'heavy'\n  | 'black';\nexport type SymbolResizeMode =\n  | 'scaleToFill'\n  | 'scaleAspectFit'\n  | 'scaleAspectFill'\n  | 'redraw'\n  | 'center'\n  | 'top'\n  | 'bottom'\n  | 'left'\n  | 'right'\n  | 'topLeft'\n  | 'topRight'\n  | 'bottomLeft'\n  | 'bottomRight';\n\n/** How a symbol animates, as `expo-symbols` describes it. */\nexport interface SymbolAnimationSpec {\n  readonly effect?: {\n    readonly type: 'bounce' | 'pulse' | 'scale';\n    readonly wholeSymbol?: boolean;\n    readonly direction?: 'up' | 'down';\n  };\n  readonly repeating?: boolean;\n  readonly repeatCount?: number;\n  readonly speed?: number;\n  readonly variableAnimationSpec?: Readonly<Record<string, boolean>>;\n}\n\n@Component({\n  selector: 'expo-symbol',\n  template: '',\n  host: {\n    '[name]': 'name()',\n    '[type]': 'type()',\n    '[scale]': 'scale()',\n    '[weight]': 'weight()',\n    '[tintColor]': 'tintColor()',\n    '[colors]': 'colourList()',\n    '[resizeMode]': 'resizeMode()',\n    '[animationSpec]': 'animationSpec()',\n    '[animated]': 'animated()',\n    '[style.width]': 'size()',\n    '[style.height]': 'size()',\n  },\n})\nexport class ExpoSymbol {\n  /** The symbol's name, as SF Symbols lists it: `heart.fill`, `cloud.sun.rain`. */\n  readonly name = input.required<string>();\n  readonly type = input<SymbolType>('monochrome');\n  readonly scale = input<SymbolScale>();\n  readonly weight = input<SymbolWeight>();\n  /** The colour of a `monochrome` or `hierarchical` symbol. */\n  readonly tintColor = input<string>();\n  /** The layers' colours, for `palette`. */\n  readonly colors = input<string | readonly string[]>();\n  readonly resizeMode = input<SymbolResizeMode>();\n  readonly animationSpec = input<SymbolAnimationSpec>();\n  /** Points, both ways. */\n  readonly size = input(24, { transform: (value: unknown) => optionalNumber(value) ?? 24 });\n\n  protected readonly colourList = computed(() => {\n    const colours = this.colors();\n    return colours === undefined ? undefined : typeof colours === 'string' ? [colours] : colours;\n  });\n  protected readonly animated = computed(() => this.animationSpec() !== undefined);\n}\n"]}