@chipmobilesdk/rn-core 0.0.0 → 0.2.0

package/CHANGELOG.md

@@ -1 +1,116 @@
 # @chipmobilesdk/rn-core
+
+## 0.2.0
+
+### Minor Changes
+
+- Every package now ships built JavaScript with declaration files, instead of asking the
+  app to compile its TypeScript. ([#22](https://github.com/operationd8979/chip-mobile-sdk/pull/22))
+
+  Each tarball carries `lib/commonjs`, `lib/module` and `lib/typescript` (built with
+  `react-native-builder-bob`), and `src/` alongside them. What that changes for a
+  consumer:
+
+  - **Nothing to add to `transformIgnorePatterns`.** `require` resolves to the CommonJS
+    build, so an app's Jest loads this package without being told to transform it. That
+    was the one thing every consuming app had to know about us (DEP-04).
+  - **Typechecking reads our `.d.ts`** rather than compiling our source under our
+    `tsconfig`. A consumer's stricter — or looser — settings no longer meet our code.
+  - **`import` resolves to ESM**, so a bundler can tree-shake what it does not use.
+
+  No exported name changed, and no subpath moved: `.`, `./testing`, `./push`,
+  `./advanced`, `./app-auth`, `./keychain` and rn-core's twelve subpaths resolve exactly
+  as before, each now with its own declarations for both module systems. publint and
+  `attw --profile node16` pass on all twelve packages, which they could not before.
+
+  Inside the monorepo nothing changed either, and that is deliberate: every subpath also
+  declares a private `chipmobilesdk-source` condition pointing at its TypeScript, and
+  Metro, Jest and `tsc` here ask for that condition first. The demo app bundles 371
+  modules straight from `packages/*/src`, so editing a package still changes the app with
+  no build step, and coverage is still measured on the source. The condition is named for
+  this organization rather than using the conventional `source` because third-party
+  packages declare that one too — `@dr.pogodin/react-native-fs` does — and asking for it
+  pulled their sources into our stricter compile.
+
+  `npm run build:packages` builds everything, `prepack` rebuilds before any `npm pack`,
+  and `lib/` is git-ignored: the published bytes are produced by the release, never
+  committed. `npm run check:manifests` now fails a package whose `main`, `module`,
+  `types`, `source` condition, `files`, build script or `prepack` do not match this shape.
+
+### Patch Changes
+
+- Each package's public API and its weight are now recorded in the repository, so a change
+  to either is reviewed rather than discovered. ([#23](https://github.com/operationd8979/chip-mobile-sdk/pull/23))
+
+  `packages/<pkg>/etc/*.api.md` is an api-extractor report per entrypoint — twenty-seven
+  of them, generated from the declarations the package publishes and committed. A renamed
+  type, a widened union, one more optional field: all of it shows up in a pull request's
+  diff. `npm run check:api` fails when a report is out of date and `npm run api:update`
+  rewrites them.
+
+  A report that moves now needs a **minor or major** changeset for that package.
+  `check:changesets` enforces it, because the report is generated from what the package
+  publishes, and a patch release that moves the public surface is how a consumer's build
+  breaks on `npm update`. A report added for the first time is a baseline, not a change.
+  `./testing` deliberately has no report: test doubles are not a surface a release is
+  gated on.
+
+  `npm run check:size` holds every entrypoint to a budget in `.size-limit.json`, measured
+  on the ESM build with peers and rn-core treated as external — they are what an app
+  installs beside us, not our weight. Each budget started at today's measurement plus five
+  per cent, so growth becomes a decision someone makes instead of a drift nobody sees. The
+  current figures run from 500 B (`rn-core/lazy`) to 19 kB (rn-notification).
+
+  No behaviour or API changed in this release; the entry is here so the changelog records
+  when the reports and the budgets began.
+
+## 0.1.0
+
+### Minor Changes
+
+- First release: the shared foundation of the @chipmobilesdk packages. `SdkError` and
+  `isSdkError` give every package one error model (`pkg`, `code`, `retryable`,
+  `redactedCause`), recognised across two copies of the package; `defineErrorCodes`
+  and `createIssueCollector` declare codes and collect config problems.
+  `createRedactor` and its primitives give one redaction mechanism with
+  identifier-only and pattern policies. `createListenerSet` and `createEmitter` notify
+  subscribers in isolation (a throwing listener is reported, never swallowed, and never
+  reaches the notifier), with a bounded dedupe. `installSdkSink` receives every
+  package's diagnostics as one `SdkDiagnostic` stream, across copies of the package.
+  `redactionConformance`
+  (`@chipmobilesdk/rn-core/testing`) checks any redaction entrypoint against a fixed set
+  of secrets. ([#17](https://github.com/operationd8979/chip-mobile-sdk/pull/17))
+
+- Port conformance suites: one list of checks that a package's fake and its real adapter
+  both pass, so a test written against the fake proves something about the device. ([#17](https://github.com/operationd8979/chip-mobile-sdk/pull/17))
+
+  - rn-core: `@chipmobilesdk/rn-core/testing` adds `runChecks`, `expectConformance`,
+    `ensure` and `createFaultRegistry` (deterministic fault injection by named point).
+  - rn-camera: a `./testing` entrypoint with `runPermissionPortConformance`,
+    `runCameraEngineConformance` and the test adapter, which stays on the main
+    entrypoint too until the next major. `createTestCamera(...).prompts()` counts system
+    prompts.
+  - rn-payment: `runProviderPortConformance` in `./testing`, passed by the fake store and
+    the Play adapter.
+  - rn-ads: `runAdsEngineConformance` in `./testing`, passed by the fake engine and the
+    AdMob adapter.
+  - rn-auth: a `./testing` entrypoint with `createMemorySecureStore`,
+    `runSecureTokenStoreConformance` and `runOidcAuthClientConformance`, passed by the
+    in-memory doubles and the keychain and app-auth adapters.
+
+- One app-lifecycle source, and a startup that needs no extra frame. ([#17](https://github.com/operationd8979/chip-mobile-sdk/pull/17))
+
+  - rn-core: `appLifecycle()`, a shared, reference-counted `AppState` subscription that
+    reports changes only (`active`, `inactive`, `background`), with `onForeground` for a
+    return from the background and `createManualLifecycle` in `./testing`.
+  - rn-camera, rn-ads and rn-notification hear the lifecycle through it instead of
+    subscribing to `AppState` each, so an app holds one native listener. The camera
+    controller's core layer no longer imports `react-native`.
+  - rn-payment: `syncOnForeground(engine)` and `<PaymentProvider syncOnForeground>` call
+    `handleForeground()` on each return from the background. Off by default; calling
+    `handleForeground()` yourself works as before.
+  - rn-i18n: `i18n.initSync()` resolves the locale before the first render when the
+    storage adapter has the new optional `getItemSync`, and returns false otherwise.
+    `localeStorageFromKeyValue(port)` builds such an adapter from rn-core's
+    `KeyValuePort` (MMKV).
+

package/lib/commonjs/diagnostics/index.js

@@ -0,0 +1,81 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createDiagnosticChannel = createDiagnosticChannel;
+exports.hasSdkSinks = hasSdkSinks;
+exports.installSdkSink = installSdkSink;
+var _index = require("../listeners/index.js");
+var _index2 = require("../redact/index.js");
+/**
+ * One diagnostic stream for every package (CORE-08).
+ *
+ * Each package keeps its own typed events (`AdEvent`, `PaymentEvent`...), and also
+ * reports what it observed as an `SdkDiagnostic` through a channel. An app installs
+ * one `DiagnosticSink` and receives every package's diagnostics in one shape, so
+ * wiring crash reporting or analytics is one adapter rather than ten.
+ *
+ * Sinks live in a registry anchored on `Symbol.for`, so a sink installed through
+ * one copy of rn-core also receives diagnostics from packages bundling another.
+ * Every context passes through a redactor before any sink sees it.
+ */
+
+const REGISTRY = Symbol.for('chipmobilesdk.diagnosticSinks');
+function sinks() {
+  const host = globalThis;
+  host[REGISTRY] ??= new Set();
+  return host[REGISTRY];
+}
+
+/**
+ * Sends every package's diagnostics to `sink` until the returned function is
+ * called. A sink that throws is reported on a fresh task and never affects the
+ * package that emitted.
+ */
+function installSdkSink(sink) {
+  const registry = sinks();
+  registry.add(sink);
+  let active = true;
+  return () => {
+    if (!active) return;
+    active = false;
+    registry.delete(sink);
+  };
+}
+
+/** Whether any sink is installed, for a package that would do extra work only to feed one. */
+function hasSdkSinks() {
+  return sinks().size > 0;
+}
+function createDiagnosticChannel(pkg, options = {}) {
+  const redactor = options.redactor ?? (0, _index2.createRedactor)();
+  const now = options.now ?? Date.now;
+  return {
+    emit(code, severity, context, correlationId) {
+      const targets = options.sink ? [options.sink, ...sinks()] : [...sinks()];
+      if (targets.length === 0) return;
+      const redacted = redactor.context(context);
+      const diagnostic = {
+        pkg,
+        code,
+        severity,
+        at: now(),
+        ...(correlationId === undefined ? {} : {
+          correlationId
+        }),
+        ...(redacted === undefined ? {} : {
+          context: redacted
+        })
+      };
+      for (const sink of targets) {
+        try {
+          sink(diagnostic);
+        } catch (error) {
+          (0, _index.reportAsynchronously)(error);
+        }
+      }
+    }
+  };
+}
+//# sourceMappingURL=index.js.map

package/lib/commonjs/diagnostics/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_index","require","_index2","REGISTRY","Symbol","for","sinks","host","globalThis","Set","installSdkSink","sink","registry","add","active","delete","hasSdkSinks","size","createDiagnosticChannel","pkg","options","redactor","createRedactor","now","Date","emit","code","severity","context","correlationId","targets","length","redacted","diagnostic","at","undefined","error","reportAsynchronously"],"sourceRoot":"../../../src","sources":["diagnostics/index.ts"],"mappings":";;;;;;;;AAaA,IAAAA,MAAA,GAAAC,OAAA;AACA,IAAAC,OAAA,GAAAD,OAAA;AAdA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAuBA,MAAME,QAAQ,GAAGC,MAAM,CAACC,GAAG,CAAC,+BAA+B,CAAC;AAE5D,SAASC,KAAKA,CAAA,EAAwB;EACrC,MAAMC,IAAI,GAAGC,UAAkD;EAC/DD,IAAI,CAACJ,QAAQ,CAAC,KAAK,IAAIM,GAAG,CAAC,CAAC;EAC5B,OAAOF,IAAI,CAACJ,QAAQ,CAAC;AACtB;;AAEA;AACA;AACA;AACA;AACA;AACO,SAASO,cAAcA,CAACC,IAAoB,EAAe;EACjE,MAAMC,QAAQ,GAAGN,KAAK,CAAC,CAAC;EACxBM,QAAQ,CAACC,GAAG,CAACF,IAAI,CAAC;EAClB,IAAIG,MAAM,GAAG,IAAI;EACjB,OAAO,MAAM;IACZ,IAAI,CAACA,MAAM,EAAE;IACbA,MAAM,GAAG,KAAK;IACdF,QAAQ,CAACG,MAAM,CAACJ,IAAI,CAAC;EACtB,CAAC;AACF;;AAEA;AACO,SAASK,WAAWA,CAAA,EAAY;EACtC,OAAOV,KAAK,CAAC,CAAC,CAACW,IAAI,GAAG,CAAC;AACxB;AAmBO,SAASC,uBAAuBA,CACtCC,GAAW,EACXC,OAAiC,GAAG,CAAC,CAAC,EACZ;EAC1B,MAAMC,QAAQ,GAAGD,OAAO,CAACC,QAAQ,IAAI,IAAAC,sBAAc,EAAC,CAAC;EACrD,MAAMC,GAAG,GAAGH,OAAO,CAACG,GAAG,IAAIC,IAAI,CAACD,GAAG;EAEnC,OAAO;IACNE,IAAIA,CAACC,IAAI,EAAEC,QAAQ,EAAEC,OAAO,EAAEC,aAAa,EAAE;MAC5C,MAAMC,OAAO,GAAGV,OAAO,CAACT,IAAI,GAAG,CAACS,OAAO,CAACT,IAAI,EAAE,GAAGL,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,GAAGA,KAAK,CAAC,CAAC,CAAC;MACxE,IAAIwB,OAAO,CAACC,MAAM,KAAK,CAAC,EAAE;MAC1B,MAAMC,QAAQ,GAAGX,QAAQ,CAACO,OAAO,CAACA,OAAO,CAAC;MAC1C,MAAMK,UAA+B,GAAG;QACvCd,GAAG;QACHO,IAAI;QACJC,QAAQ;QACRO,EAAE,EAAEX,GAAG,CAAC,CAAC;QACT,IAAIM,aAAa,KAAKM,SAAS,GAAG,CAAC,CAAC,GAAG;UAAEN;QAAc,CAAC,CAAC;QACzD,IAAIG,QAAQ,KAAKG,SAAS,GAAG,CAAC,CAAC,GAAG;UAAEP,OAAO,EAAEI;QAAS,CAAC;MACxD,CAAC;MACD,KAAK,MAAMrB,IAAI,IAAImB,OAAO,EAAE;QAC3B,IAAI;UACHnB,IAAI,CAACsB,UAAU,CAAC;QACjB,CAAC,CAAC,OAAOG,KAAK,EAAE;UACf,IAAAC,2BAAoB,EAACD,KAAK,CAAC;QAC5B;MACD;IACD;EACD,CAAC;AACF","ignoreList":[]}

package/lib/commonjs/errors/index.js

@@ -0,0 +1,86 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SdkError = void 0;
+exports.createIssueCollector = createIssueCollector;
+exports.defineErrorCodes = defineErrorCodes;
+exports.isSdkError = isSdkError;
+/**
+ * One error model for every @chipmobilesdk package (CORE-11).
+ *
+ * Each package keeps its own public error class and code union (`AdsError`,
+ * `PaymentError`...); those classes extend `SdkError`, so an app can handle any
+ * package's failure the same way: a code, whether retrying can help, and a cause
+ * that has already been through redaction.
+ *
+ * `isSdkError` checks a brand rather than `instanceof`, so it holds when an app
+ * ends up with two copies of this package (two versions in node_modules), which
+ * would make `instanceof SdkError` false for half its errors.
+ */
+
+const BRAND = Symbol.for('chipmobilesdk.error');
+class SdkError extends Error {
+  /** The package that raised the error, e.g. `rn-ads`. */
+
+  constructor(pkg, code, options = {}) {
+    super(options.message ?? code);
+    this.name = 'SdkError';
+    this.pkg = pkg;
+    this.code = code;
+    this.retryable = options.retryable ?? false;
+    if (options.redactedCause !== undefined) {
+      this.redactedCause = options.redactedCause;
+    }
+    // Keeps subclasses' prototypes intact where Error subclassing is transpiled.
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+}
+exports.SdkError = SdkError;
+Object.defineProperty(SdkError.prototype, BRAND, {
+  value: true
+});
+
+/** True for an error raised by any @chipmobilesdk package, from any copy of this one. */
+function isSdkError(value) {
+  return typeof value === 'object' && value !== null && value[BRAND] === true;
+}
+/**
+ * A package's closed code set and which of its codes are retryable, declared
+ * once instead of a union, an array and a `Set` kept in step by hand.
+ */
+function defineErrorCodes(codes, options = {}) {
+  const all = new Set(codes);
+  const retryable = new Set(options.retryable ?? []);
+  return {
+    codes: Object.freeze([...codes]),
+    is: value => typeof value === 'string' && all.has(value),
+    isRetryable: code => retryable.has(code)
+  };
+}
+/**
+ * Collects every problem in a config before throwing, so an app sees all of them
+ * at once rather than one per fix-and-restart cycle.
+ */
+function createIssueCollector() {
+  const issues = [];
+  return {
+    add(path, message) {
+      issues.push({
+        path,
+        message
+      });
+    },
+    get issues() {
+      return issues;
+    },
+    /** Throws what `toError` builds from the issues, when there are any. */
+    throwIfAny(toError) {
+      if (issues.length > 0) {
+        throw toError([...issues]);
+      }
+    }
+  };
+}
+//# sourceMappingURL=index.js.map

package/lib/commonjs/errors/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["BRAND","Symbol","for","SdkError","Error","constructor","pkg","code","options","message","name","retryable","redactedCause","undefined","Object","setPrototypeOf","new","target","prototype","exports","defineProperty","value","isSdkError","defineErrorCodes","codes","all","Set","freeze","is","has","isRetryable","createIssueCollector","issues","add","path","push","throwIfAny","toError","length"],"sourceRoot":"../../../src","sources":["errors/index.ts"],"mappings":";;;;;;;;;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,MAAMA,KAAK,GAAGC,MAAM,CAACC,GAAG,CAAC,qBAAqB,CAAC;AAWxC,MAAMC,QAAQ,SAAuCC,KAAK,CAAC;EACjE;;EAMAC,WAAWA,CAACC,GAAW,EAAEC,IAAU,EAAEC,OAAwB,GAAG,CAAC,CAAC,EAAE;IACnE,KAAK,CAACA,OAAO,CAACC,OAAO,IAAIF,IAAI,CAAC;IAC9B,IAAI,CAACG,IAAI,GAAG,UAAU;IACtB,IAAI,CAACJ,GAAG,GAAGA,GAAG;IACd,IAAI,CAACC,IAAI,GAAGA,IAAI;IAChB,IAAI,CAACI,SAAS,GAAGH,OAAO,CAACG,SAAS,IAAI,KAAK;IAC3C,IAAIH,OAAO,CAACI,aAAa,KAAKC,SAAS,EAAE;MACxC,IAAI,CAACD,aAAa,GAAGJ,OAAO,CAACI,aAAa;IAC3C;IACA;IACAE,MAAM,CAACC,cAAc,CAAC,IAAI,EAAEC,GAAG,CAACC,MAAM,CAACC,SAAS,CAAC;EAClD;AACD;AAACC,OAAA,CAAAhB,QAAA,GAAAA,QAAA;AAEDW,MAAM,CAACM,cAAc,CAACjB,QAAQ,CAACe,SAAS,EAAElB,KAAK,EAAE;EAAEqB,KAAK,EAAE;AAAK,CAAC,CAAC;;AAEjE;AACO,SAASC,UAAUA,CAACD,KAAc,EAAqB;EAC7D,OACC,OAAOA,KAAK,KAAK,QAAQ,IAAIA,KAAK,KAAK,IAAI,IAAKA,KAAK,CAA2BrB,KAAK,CAAC,KAAK,IAAI;AAEjG;AASA;AACA;AACA;AACA;AACO,SAASuB,gBAAgBA,CAC/BC,KAAsB,EACtBhB,OAA0D,GAAG,CAAC,CAAC,EAC5C;EACnB,MAAMiB,GAAG,GAAG,IAAIC,GAAG,CAASF,KAAK,CAAC;EAClC,MAAMb,SAAS,GAAG,IAAIe,GAAG,CAASlB,OAAO,CAACG,SAAS,IAAI,EAAE,CAAC;EAC1D,OAAO;IACNa,KAAK,EAAEV,MAAM,CAACa,MAAM,CAAC,CAAC,GAAGH,KAAK,CAAC,CAAC;IAChCI,EAAE,EAAGP,KAAc,IAAoB,OAAOA,KAAK,KAAK,QAAQ,IAAII,GAAG,CAACI,GAAG,CAACR,KAAK,CAAC;IAClFS,WAAW,EAAEvB,IAAI,IAAII,SAAS,CAACkB,GAAG,CAACtB,IAAI;EACxC,CAAC;AACF;AAQA;AACA;AACA;AACA;AACO,SAASwB,oBAAoBA,CAAA,EAAG;EACtC,MAAMC,MAAqB,GAAG,EAAE;EAChC,OAAO;IACNC,GAAGA,CAACC,IAAY,EAAEzB,OAAe,EAAQ;MACxCuB,MAAM,CAACG,IAAI,CAAC;QAAED,IAAI;QAAEzB;MAAQ,CAAC,CAAC;IAC/B,CAAC;IACD,IAAIuB,MAAMA,CAAA,EAA2B;MACpC,OAAOA,MAAM;IACd,CAAC;IACD;IACAI,UAAUA,CAACC,OAAkD,EAAQ;MACpE,IAAIL,MAAM,CAACM,MAAM,GAAG,CAAC,EAAE;QACtB,MAAMD,OAAO,CAAC,CAAC,GAAGL,MAAM,CAAC,CAAC;MAC3B;IACD;EACD,CAAC;AACF","ignoreList":[]}

package/lib/commonjs/index.js

@@ -0,0 +1,305 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "COMMON_PATTERNS", {
+  enumerable: true,
+  get: function () {
+    return _index2.COMMON_PATTERNS;
+  }
+});
+Object.defineProperty(exports, "PATH_PATTERN", {
+  enumerable: true,
+  get: function () {
+    return _index2.PATH_PATTERN;
+  }
+});
+Object.defineProperty(exports, "REDACTED", {
+  enumerable: true,
+  get: function () {
+    return _index2.REDACTED;
+  }
+});
+Object.defineProperty(exports, "SdkError", {
+  enumerable: true,
+  get: function () {
+    return _index.SdkError;
+  }
+});
+Object.defineProperty(exports, "appLifecycle", {
+  enumerable: true,
+  get: function () {
+    return _index8.appLifecycle;
+  }
+});
+Object.defineProperty(exports, "byPlatform", {
+  enumerable: true,
+  get: function () {
+    return _index8.byPlatform;
+  }
+});
+Object.defineProperty(exports, "checkInteger", {
+  enumerable: true,
+  get: function () {
+    return _index5.checkInteger;
+  }
+});
+Object.defineProperty(exports, "checkRange", {
+  enumerable: true,
+  get: function () {
+    return _index5.checkRange;
+  }
+});
+Object.defineProperty(exports, "clearIntlCaches", {
+  enumerable: true,
+  get: function () {
+    return _index0.clearIntlCaches;
+  }
+});
+Object.defineProperty(exports, "computeBackoff", {
+  enumerable: true,
+  get: function () {
+    return _index5.computeBackoff;
+  }
+});
+Object.defineProperty(exports, "createAppLifecycle", {
+  enumerable: true,
+  get: function () {
+    return _index8.createAppLifecycle;
+  }
+});
+Object.defineProperty(exports, "createDiagnosticChannel", {
+  enumerable: true,
+  get: function () {
+    return _index4.createDiagnosticChannel;
+  }
+});
+Object.defineProperty(exports, "createEmitter", {
+  enumerable: true,
+  get: function () {
+    return _index3.createEmitter;
+  }
+});
+Object.defineProperty(exports, "createExclusive", {
+  enumerable: true,
+  get: function () {
+    return _index5.createExclusive;
+  }
+});
+Object.defineProperty(exports, "createIssueCollector", {
+  enumerable: true,
+  get: function () {
+    return _index.createIssueCollector;
+  }
+});
+Object.defineProperty(exports, "createListenerSet", {
+  enumerable: true,
+  get: function () {
+    return _index3.createListenerSet;
+  }
+});
+Object.defineProperty(exports, "createMemoryKeyValue", {
+  enumerable: true,
+  get: function () {
+    return _index7.createMemoryKeyValue;
+  }
+});
+Object.defineProperty(exports, "createRateLimiter", {
+  enumerable: true,
+  get: function () {
+    return _index5.createRateLimiter;
+  }
+});
+Object.defineProperty(exports, "createRedactor", {
+  enumerable: true,
+  get: function () {
+    return _index2.createRedactor;
+  }
+});
+Object.defineProperty(exports, "createSingleFlight", {
+  enumerable: true,
+  get: function () {
+    return _index5.createSingleFlight;
+  }
+});
+Object.defineProperty(exports, "createStore", {
+  enumerable: true,
+  get: function () {
+    return _index9.createStore;
+  }
+});
+Object.defineProperty(exports, "createTimerSet", {
+  enumerable: true,
+  get: function () {
+    return _index5.createTimerSet;
+  }
+});
+Object.defineProperty(exports, "currentPlatform", {
+  enumerable: true,
+  get: function () {
+    return _index8.currentPlatform;
+  }
+});
+Object.defineProperty(exports, "defineErrorCodes", {
+  enumerable: true,
+  get: function () {
+    return _index.defineErrorCodes;
+  }
+});
+Object.defineProperty(exports, "defineMessages", {
+  enumerable: true,
+  get: function () {
+    return _index1.defineMessages;
+  }
+});
+Object.defineProperty(exports, "describeShape", {
+  enumerable: true,
+  get: function () {
+    return _index2.describeShape;
+  }
+});
+Object.defineProperty(exports, "formatMessage", {
+  enumerable: true,
+  get: function () {
+    return _index1.formatMessage;
+  }
+});
+Object.defineProperty(exports, "fromMmkvLike", {
+  enumerable: true,
+  get: function () {
+    return _index7.fromMmkvLike;
+  }
+});
+Object.defineProperty(exports, "getDateTimeFormat", {
+  enumerable: true,
+  get: function () {
+    return _index0.getDateTimeFormat;
+  }
+});
+Object.defineProperty(exports, "getNumberFormat", {
+  enumerable: true,
+  get: function () {
+    return _index0.getNumberFormat;
+  }
+});
+Object.defineProperty(exports, "hasSdkSinks", {
+  enumerable: true,
+  get: function () {
+    return _index4.hasSdkSinks;
+  }
+});
+Object.defineProperty(exports, "installSdkSink", {
+  enumerable: true,
+  get: function () {
+    return _index4.installSdkSink;
+  }
+});
+Object.defineProperty(exports, "isDevBuild", {
+  enumerable: true,
+  get: function () {
+    return _index8.isDevBuild;
+  }
+});
+Object.defineProperty(exports, "isSdkError", {
+  enumerable: true,
+  get: function () {
+    return _index.isSdkError;
+  }
+});
+Object.defineProperty(exports, "isValidTimeZone", {
+  enumerable: true,
+  get: function () {
+    return _index0.isValidTimeZone;
+  }
+});
+Object.defineProperty(exports, "lazyPeer", {
+  enumerable: true,
+  get: function () {
+    return _index6.lazyPeer;
+  }
+});
+Object.defineProperty(exports, "leadingIdentifier", {
+  enumerable: true,
+  get: function () {
+    return _index2.leadingIdentifier;
+  }
+});
+Object.defineProperty(exports, "namespaced", {
+  enumerable: true,
+  get: function () {
+    return _index7.namespaced;
+  }
+});
+Object.defineProperty(exports, "onForeground", {
+  enumerable: true,
+  get: function () {
+    return _index8.onForeground;
+  }
+});
+Object.defineProperty(exports, "openDurable", {
+  enumerable: true,
+  get: function () {
+    return _index7.openDurable;
+  }
+});
+Object.defineProperty(exports, "pickAllowed", {
+  enumerable: true,
+  get: function () {
+    return _index2.pickAllowed;
+  }
+});
+Object.defineProperty(exports, "realScheduler", {
+  enumerable: true,
+  get: function () {
+    return _index5.realScheduler;
+  }
+});
+Object.defineProperty(exports, "redactPatterns", {
+  enumerable: true,
+  get: function () {
+    return _index2.redactPatterns;
+  }
+});
+Object.defineProperty(exports, "reportAsynchronously", {
+  enumerable: true,
+  get: function () {
+    return _index3.reportAsynchronously;
+  }
+});
+Object.defineProperty(exports, "runWithRetry", {
+  enumerable: true,
+  get: function () {
+    return _index5.runWithRetry;
+  }
+});
+Object.defineProperty(exports, "setPlatformOverride", {
+  enumerable: true,
+  get: function () {
+    return _index8.setPlatformOverride;
+  }
+});
+Object.defineProperty(exports, "shallowEqual", {
+  enumerable: true,
+  get: function () {
+    return _index9.shallowEqual;
+  }
+});
+Object.defineProperty(exports, "withTimeout", {
+  enumerable: true,
+  get: function () {
+    return _index5.withTimeout;
+  }
+});
+var _index = require("./errors/index.js");
+var _index2 = require("./redact/index.js");
+var _index3 = require("./listeners/index.js");
+var _index4 = require("./diagnostics/index.js");
+var _index5 = require("./scheduler/index.js");
+var _index6 = require("./lazy/index.js");
+var _index7 = require("./kv/index.js");
+var _index8 = require("./runtime/index.js");
+var _index9 = require("./store/index.js");
+var _index0 = require("./intl/index.js");
+var _index1 = require("./messages/index.js");
+//# sourceMappingURL=index.js.map

package/lib/commonjs/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_index","require","_index2","_index3","_index4","_index5","_index6","_index7","_index8","_index9","_index0","_index1"],"sourceRoot":"../../src","sources":["index.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAUA,IAAAA,MAAA,GAAAC,OAAA;AASA,IAAAC,OAAA,GAAAD,OAAA;AAYA,IAAAE,OAAA,GAAAF,OAAA;AAWA,IAAAG,OAAA,GAAAH,OAAA;AAUA,IAAAI,OAAA,GAAAJ,OAAA;AAmBA,IAAAK,OAAA,GAAAL,OAAA;AACA,IAAAM,OAAA,GAAAN,OAAA;AAQA,IAAAO,OAAA,GAAAP,OAAA;AAcA,IAAAQ,OAAA,GAAAR,OAAA;AACA,IAAAS,OAAA,GAAAT,OAAA;AACA,IAAAU,OAAA,GAAAV,OAAA","ignoreList":[]}