@pomwik/afterdb-react 0.0.0-stage → 0.20.1

package/CHANGES-FROM-UPSTREAM.md

@@ -0,0 +1,57 @@
+# Changes from upstream
+
+`@pomwik/afterdb` and `@pomwik/afterdb-react` repackage the official npm tarballs `realm@20.2.0` and
+`@realm/react@0.20.0` of the Realm® JavaScript SDK (Apache-2.0). The prebuilt realm-core engine is not recompiled or
+changed.
+
+Realm® is a trademark of MongoDB, Inc. This project is independent and not affiliated with or endorsed by MongoDB.
+
+Every file listed here was modified, removed or added. Modified text files carry a « Modified by Pomwik (Firas
+Hmedi), 2026 » note, except `package.json`: JSON has no comments, so it carries an `afterdb` field instead (upstream
+name, version and npm integrity).
+
+## @pomwik/afterdb 20.3.0 (from realm@20.2.0)
+
+| File | Change | Why |
+|---|---|---|
+| `package.json` | `name` and `version` | New package |
+| `package.json` | `description`, `homepage`, `repository`, `bugs` and `author` replaced (Pomwik, github.com/FirasHmedi/afterdb); `mongodb` removed from `keywords` | The package is not MongoDB's and must not look like it |
+| `package.json` | `license`: `Apache-2.0` instead of upstream's `apache-2.0` (the podspec's `s.license` reads it too) | `Apache-2.0` is the SPDX identifier that npm expects; the licence itself is unchanged |
+| `package.json` | `install` and `postinstall` scripts removed; `prebuild-install` and `node-machine-id` dependencies removed; `binary` field removed; `exports["./scripts/submit-analytics"]` removed | No download and no analytics at install time (realm/realm-js#7119, #7068, #7126) |
+| `package.json` | `imports["#realm.node"]` removed | Its only user was `dist/platform/node/binding.js` (patched below); the build checks that nothing else in the package refers to it |
+| `package.json` | `gypfile: false`; `files`: `binding.gyp` removed, `prebuilds/node`, `LICENSE`, `NOTICE`, `THIRD-PARTY-NOTICES.md`, `CHANGES-FROM-UPSTREAM.md` and `checksums.txt` added | See `binding.gyp` below; the added files ship in the package |
+| `package.json` | `afterdb` field added | Marks the file as modified, and records where it comes from |
+| `dist/scripts/submit-analytics.*`, `scripts/submit-analytics.js` | Removed | Install-time analytics |
+| `prebuilds/node/<platform>-<arch>/realm.node` | Added: the upstream N-API binaries for darwin-arm64, darwin-x64, linux-x64, linux-arm64, win32-x64 | Installs work offline and in CI |
+| `dist/platform/node/binding.js` | Loads the binary of the current platform; if none is shipped for it, throws an error that names the platform and the 5 shipped ones (instead of the upstream `#realm.node` lookup) | Same, and a clear message instead of a module-not-found error |
+| `RealmJS.podspec` | `install_modules_dependencies(s)` instead of `s.dependency 'React'` | iOS linking on React Native >= 0.86 with frameworks (realm/realm-js#7157, fix by TPXP, reused with credit) |
+| `RealmJS.podspec` | `HEADER_SEARCH_PATHS` is a string instead of an array | React Native's `install_modules_dependencies` appends to it as a string, so the array became `["..."] …` and broke header lookups (found by the independent review) |
+| `RealmJS.podspec` | `REALM_ENABLE_SYNC=1` removed from the preprocessor flags, and the upstream comment above it (« compiled with Sync enabled ») replaced | v20 has no sync; no shipped header or binding source reads it |
+| `RealmJS.podspec` | `s.platform`: React Native's minimum iOS version (`min_ios_version_supported`) when React Native defines it, otherwise 15.1, instead of iOS 9.0 | 9.0 is far below what React Native >= 0.71 supports |
+| `binding/android/build.gradle` | `ndkVersion rootProject.ext.ndkVersion` when the app defines it, as React Native libraries do; otherwise AGP's default, as before | `librealm.so` was built with AGP's default NDK (27.0 with AGP 8.12, 28.2 with AGP 9.2) instead of the app's |
+| `binding/android/build.gradle`, new `binding/android/consumer-rules.pro` | `consumerProguardFiles 'consumer-rules.pro'` with `-keep class io.realm.react.** { *; }` | With R8 in the app's release build (on by default in Expo SDK 58), `io.realm.react.util.SSLHelper`, looked up only from native code (`FindClass` in `JNI_OnLoad`), was removed and the app crashed at start with `ClassNotFoundException`. Found with the Expo 58 example on 2026-11-06 |
+| `prebuilds/apple/realm-core.xcframework/*/Headers/external/s2/base/macros.h` | `DECLARE_POD` and `PROPAGATE_POD_FROM_TEMPLATE_ARGUMENT` no longer specialize `std::is_pod` | Build error on Xcode 26.4 (realm/realm-js#7115) |
+| `prebuilds/android/<abi>/deps/openssl-3.5.9-*.tar.gz` | Added: OpenSSL 3.5.9 LTS built from the checksummed OpenSSL source release by `bridge/openssl/build-openssl.sh` (static, no apps, no engines), entries owned by 0:0. Each archive also holds OpenSSL's `LICENSE.txt` and an `include.cmake` that is upstream's file, byte-identical to the one in realm's `openssl-3.3.1` archives (SHA-256 `00510e01b73e57960852921903df79ca5c9e54086483a349d3d05dff7d1cf28a`) | The Android build no longer downloads anything, and OpenSSL 3.3 is end-of-life since 2026-04-09 |
+| `prebuilds/android/<abi>/share/cmake/Realm/RealmConfig.cmake` | Acquires OpenSSL 3.5.9 instead of 3.3.1 | Same |
+| `prebuilds/android/<abi>/share/cmake/Realm/AcquireRealmDependency.cmake` | Uses the bundled archive, downloads only as a fallback; the SHA-256 of the bundled archive is written into the file at build time, and CMake checks it with `file(SHA256)` before using the archive (a mismatch stops the build with `FATAL_ERROR`); the extraction folder includes the version (`openssl-3.5.9`) | Same, a damaged archive is never used, and a build folder left by upstream (OpenSSL 3.3.1) is never reused |
+| `binding.gyp` | Removed | It only rebuilds the Node binary from source; npm would otherwise run node-gyp at install |
+| `README.md` | Replaced, with a « Modified by Pomwik (Firas Hmedi), 2026 » note | Describes this package |
+| `LICENSE`, `NOTICE`, `THIRD-PARTY-NOTICES.md`, `CHANGES-FROM-UPSTREAM.md`, `checksums.txt` | Added (the upstream tarball has no LICENSE file). `THIRD-PARTY-NOTICES.md` lists the third-party code inside the prebuilt realm-core engine and the Node binaries, with its licence texts | Licence and traceability |
+| `RealmJS.podspec`, `binding/android` | Not renamed, on purpose: the iOS pod `RealmJS`, the Android namespace `io.realm.react` and the native library `librealm.so` keep their upstream names. The pod version follows the package version (20.3.0, not an upstream release) | Drop-in compatibility: React Native autolinking, existing Podfiles and lockfiles, and the native code that looks up `io.realm.react` classes by name keep working unchanged |
+
+## @pomwik/afterdb-react 0.20.1 (from @realm/react@0.20.0)
+
+| File | Change | Why |
+|---|---|---|
+| `package.json` | `name` and `version` | New package |
+| `package.json` | `description`, `homepage`, `repository`, `bugs` (upstream: the realm/realm-js issues) and `author` replaced, as in `@pomwik/afterdb` | Same |
+| `package.json` | `react-native` moved from `optionalDependencies` to an optional peer dependency; the `realm` peer range (`>=20.0.0`) is unchanged, and `@pomwik/afterdb` satisfies it through the `realm` npm alias | A nested copy of react-native broke Android builds (realm/realm-js#7066) |
+| `package.json` | `files`: `NOTICE` and `CHANGES-FROM-UPSTREAM.md` added (`LICENSE` was already listed upstream, once) | The added files ship in the package |
+| `package.json` | `afterdb` field added | Marks the file as modified, and records where it comes from |
+| `README.md` | Replaced, with a « Modified by Pomwik (Firas Hmedi), 2026 » note | Describes this package |
+| `LICENSE`, `NOTICE`, `CHANGES-FROM-UPSTREAM.md` | Added (the upstream tarball has no LICENSE file). This `NOTICE` has no OpenSSL paragraph: the package ships no OpenSSL | Licence and traceability |
+
+## Credits
+
+- TPXP: the podspec fix for React Native >= 0.86 (realm/realm-js#7157).
+- MongoDB, Inc. and the Realm JS contributors: everything else (Apache-2.0).

package/LICENSE

@@ -0,0 +1,177 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+

package/NOTICE

@@ -0,0 +1,9 @@
+afterdb-react
+Copyright 2026 Pomwik (Firas Hmedi)
+
+This product includes software developed by MongoDB, Inc. and the Realm JS
+contributors (https://github.com/realm/realm-js), licensed under the Apache
+License, Version 2.0. The upstream copyright notices are kept in the source files.
+
+Realm(R) is a trademark of MongoDB, Inc. afterdb is an independent project.
+It is not affiliated with, sponsored by or endorsed by MongoDB, Inc.

package/README.md

@@ -1,3 +1,11 @@
-# Temporary Holding Version
+# @pomwik/afterdb-react
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+The `@realm/react` 0.20.0 hooks for Realm® (RealmProvider, useQuery, useObject, useRealm), repackaged for
+@pomwik/afterdb, with `react-native` as an optional peer dependency instead of a nested copy (realm/realm-js#7066).
+Use it through an npm alias: `"@realm/react": "npm:@pomwik/afterdb-react@0.20.1"`, next to
+`"realm": "npm:@pomwik/afterdb@20.3.0"`. Changes: see CHANGES-FROM-UPSTREAM.md.
+
+Realm® is a trademark of MongoDB, Inc. This project is independent and not affiliated with or endorsed by MongoDB.
+Licence: Apache-2.0 (see LICENSE and NOTICE).
+
+Modified by Pomwik (Firas Hmedi), 2026: this file replaces the upstream README (see CHANGES-FROM-UPSTREAM.md).

package/dist/RealmContext.d.ts

@@ -0,0 +1,153 @@
+import { createUseObject } from "./useObject";
+import { createUseQuery } from "./useQuery";
+import { createUseRealm } from "./useRealm";
+import { DynamicRealmProvider, RealmProviderFromConfiguration, RealmProviderFromRealm } from "./RealmProvider";
+import Realm from "realm";
+export type RealmContext<RealmProvider = DynamicRealmProvider> = {
+    /**
+     * The Provider component that is required to wrap any component using
+     * the Realm hooks.
+     * @example
+     * ```
+     * const AppRoot = () => {
+     *   const syncConfig = {
+     *     flexible: true,
+     *     user: currentUser
+     *   };
+     *
+     *   return (
+     *     <RealmProvider schema={[Task, User]} path={"data.realm"} sync={syncConfig}>
+     *       <App/>
+     *     </RealmProvider>
+     *   )
+     * }
+     * ```
+     * @param props - The {@link Realm.Configuration} or {@link Realm} of the provider
+     * are set based on the options passed to `createRealmProvider`. When using a
+     * {@link Realm.Configuration}, individual config keys can be overridden when
+     * creating a `<RealmProvider>` by passing them as props. For example, to override
+     * the `path` config value, use a prop named `path` e.g., `path="newPath.realm"` an
+     * attribute of the same key.
+     */
+    RealmProvider: RealmProvider;
+    /**
+     * Returns the instance of the {@link Realm} opened by the `RealmProvider`.
+     * @example
+     * ```
+     * const realm = useRealm();
+     * ```
+     * @returns a realm instance
+     */
+    useRealm: ReturnType<typeof createUseRealm>;
+    /**
+     * Returns a {@link Realm.Collection} of {@link Realm.Object}s from a given type.
+     * The hook will update on any changes to any object in the collection.
+     *
+     * The result of this can be consumed directly by the `data` argument of any React Native
+     * VirtualizedList or FlatList.  If the component used for the list's `renderItem` prop is {@link React.Memo}ized,
+     * then only the modified object will re-render.
+     * @example
+     * ```tsx
+     * // Return all collection items
+     * const collection = useQuery({ type: Object });
+     *
+     * // Return all collection items sorted by name and filtered by category
+     * const filteredAndSorted = useQuery({
+     *   type: Object,
+     *   query: (collection) => collection.filtered('category == $0',category).sorted('name'),
+     * }, [category]);
+     *
+     * // Return all collection items sorted by name and filtered by category, triggering re-renders only if "name" changes
+     * const filteredAndSorted = useQuery({
+     *   type: Object,
+     *   query: (collection) => collection.filtered('category == $0',category).sorted('name'),
+     *   keyPaths: ["name"]
+     * }, [category]);
+     * ```
+     * @param options
+     * @param options.type - The object type, depicted by a string or a class extending Realm.Object
+     * @param options.query - A function that takes a {@link Realm.Collection} and returns a {@link Realm.Collection} of the same type. This allows for filtering and sorting of the collection, before it is returned.
+     * @param options.keyPaths - Indicates a lower bound on the changes relevant for the hook. This is a lower bound, since if multiple hooks add listeners (each with their own `keyPaths`) the union of these key-paths will determine the changes that are considered relevant for all listeners registered on the collection. In other words: A listener might fire and cause a re-render more than the key-paths specify, if other listeners with different key-paths are present.
+     * @param deps - An array of dependencies that will be passed to {@link React.useMemo}
+     * @returns a collection of realm objects or an empty array
+     */
+    useQuery: ReturnType<typeof createUseQuery>;
+    /**
+     * Returns a {@link Realm.Object} from a given type and value of primary key.
+     * The hook will update on any changes to the properties on the returned object
+     * and return null if it either doesn't exists or has been deleted.
+     * @example
+     * ```
+     * const object = useObject(ObjectClass, objectId);
+     * ```
+     * @param type - The object type, depicted by a string or a class extending {@link Realm.Object}
+     * @param primaryKey - The primary key of the desired object which will be retrieved using {@link Realm.objectForPrimaryKey}
+     * @param keyPaths - Indicates a lower bound on the changes relevant for the hook. This is a lower bound, since if multiple hooks add listeners (each with their own `keyPaths`) the union of these key-paths will determine the changes that are considered relevant for all listeners registered on the object. In other words: A listener might fire and cause a re-render more than the key-paths specify, if other listeners with different key-paths are present.
+     * @returns either the desired {@link Realm.Object} or `null` in the case of it being deleted or not existing.
+     */
+    useObject: ReturnType<typeof createUseObject>;
+};
+/**
+ * Creates Realm React hooks and Provider component for a given Realm configuration
+ * @example
+ * ```
+ *class Task extends Realm.Object {
+ *  ...
+ *
+ *  static schema: ObjectSchema = {
+ *    name: 'Task',
+ *    primaryKey: '_id',
+ *    properties: {
+ *      ...
+ *    },
+ *  };
+ *}
+ *
+ *const {useRealm, useQuery, useObject, RealmProvider} = createRealmContext({schema: [Task]});
+ * ```
+ * @param realmConfig - {@link Realm.Configuration} used to open the Realm
+ * @returns An object containing a `RealmProvider` component, and `useRealm`, `useQuery` and `useObject` hooks
+ */
+export declare function createRealmContext(realmConfig: Realm.Configuration): RealmContext<RealmProviderFromConfiguration>;
+/**
+ * Creates Realm React hooks and Provider component for a given Realm instance.
+ *
+ * **Note:** the hooks returned from `createRealmContext` using an existing Realm can be used outside of the scope of the provider.
+ * @example
+ * ```
+ * const realm = new Realm({ schema: [...] });
+ * const {useRealm, useQuery, useObject, RealmProvider} = createRealmContext(realm);
+ * ```
+ * @param realm - {@link Realm} instance
+ * @returns An object containing a `RealmProvider` component, and `useRealm`, `useQuery` and `useObject` hooks
+ */
+export declare function createRealmContext(realm: Realm): RealmContext<RealmProviderFromRealm>;
+/**
+ * Creates Realm React hooks and Provider component.
+ * @example
+ * ```
+ * class Task extends Realm.Object {
+ *  ...
+ *  static schema: ObjectSchema = {
+ *    name: 'Task',
+ *    primaryKey: '_id',
+ *    properties: {
+ *      ...
+ *    },
+ *  };
+ * }
+ * const {useRealm, useQuery, useObject, RealmProvider} = createRealmContext();
+ * ...
+ * <RealmProvider schema={[Task]}></RealmProvider>
+ * ```
+ * @example
+ * ```
+ * const realm = await Realm.open({ path: "example.realm", schema: [Task] });
+ * const {RealmProvider} = createRealmContext();
+ * ...
+ * <RealmProvider realm={realm}></RealmProvider>
+ * ```
+ * @returns An object containing a `RealmProvider` component, and `useRealm`, `useQuery` and `useObject` hooks
+ */
+export declare function createRealmContext(): RealmContext<DynamicRealmProvider>;
+//# sourceMappingURL=RealmContext.d.ts.map

package/dist/RealmContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RealmContext.d.ts","sourceRoot":"","sources":["../src/RealmContext.ts"],"names":[],"mappings":"AAkBA,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAC9C,OAAO,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAC5C,OAAO,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAC5C,OAAO,EACL,oBAAoB,EACpB,8BAA8B,EAC9B,sBAAsB,EAEvB,MAAM,iBAAiB,CAAC;AAEzB,OAAO,KAAK,MAAM,OAAO,CAAC;AAE1B,MAAM,MAAM,YAAY,CAAC,aAAa,GAAG,oBAAoB,IAAI;IAC/D;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,aAAa,EAAE,aAAa,CAAC;IAC7B;;;;;;;OAOG;IACH,QAAQ,EAAE,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;IAE5C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+BG;IACH,QAAQ,EAAE,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;IAC5C;;;;;;;;;;;;OAYG;IACH,SAAS,EAAE,UAAU,CAAC,OAAO,eAAe,CAAC,CAAC;CAC/C,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,kBAAkB,CAAC,WAAW,EAAE,KAAK,CAAC,aAAa,GAAG,YAAY,CAAC,8BAA8B,CAAC,CAAC;AACnH;;;;;;;;;;;GAWG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,KAAK,GAAG,YAAY,CAAC,sBAAsB,CAAC,CAAC;AACvF;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,kBAAkB,IAAI,YAAY,CAAC,oBAAoB,CAAC,CAAC"}

package/dist/RealmProvider.d.ts

@@ -0,0 +1,95 @@
+import React from "react";
+import Realm from "realm";
+import { RestrictivePick } from "./helpers";
+type PartialRealmConfiguration = Partial<Realm.Configuration>;
+export type RealmProviderFallback = React.ComponentType;
+/** Props used for a configuration-based Realm provider */
+type RealmProviderConfigurationProps = {
+    /**
+     * If false, Realm will not be closed when the component unmounts.
+     * @default true
+     */
+    closeOnUnmount?: boolean;
+    /**
+     * A ref to the Realm instance. This is useful if you need to access the Realm
+     * instance outside of a component that uses the Realm hooks.
+     */
+    realmRef?: React.MutableRefObject<Realm | null>;
+    /**
+     * The fallback component to render if the Realm is not open.
+     */
+    fallback?: RealmProviderFallback | React.ComponentType | React.ReactElement | null | undefined;
+    children: React.ReactNode;
+} & PartialRealmConfiguration;
+/** Props used for a Realm instance-based Realm provider */
+type RealmProviderRealmProps = {
+    /**
+     * The Realm instance to be used by the provider.
+     */
+    realm: Realm;
+    children: React.ReactNode;
+};
+type RealmProviderProps = RealmProviderConfigurationProps & RealmProviderRealmProps;
+/**
+ * Represents the provider returned from `createRealmContext` with a Realm instance  i.e. `createRealmContext(new Realm(...))`.
+ * Omits "realm" as it gets set at creation and cannot be changed.
+ 
+ * **Note:** the hooks returned from `createRealmContext` using an existing Realm can be used outside of the scope of the provider.
+ */
+export type RealmProviderFromRealm = React.FC<Omit<RealmProviderRealmProps, "realm">>;
+/**
+ * Represents the provider returned from `createRealmContext` with a configuration, i.e. `createRealmContext({schema: [...]})`.
+ */
+export type RealmProviderFromConfiguration = React.FC<RealmProviderConfigurationProps>;
+/**
+ * Represents properties of a {@link DynamicRealmProvider} where Realm instance props are set and Configuration props are disallowed.
+ */
+export type DynamicRealmProviderWithRealmProps = RestrictivePick<RealmProviderProps, keyof RealmProviderRealmProps>;
+/**
+ * Represents properties of a {@link DynamicRealmProvider} where Realm configuration props are set and Realm instance props are disallowed.
+ */
+export type DynamicRealmProviderWithConfigurationProps = RestrictivePick<RealmProviderProps, keyof RealmProviderConfigurationProps>;
+/**
+ * Represents the provider returned from creating context with no arguments (including the default context).
+ * Supports either {@link RealmProviderRealmProps} or {@link RealmProviderConfigurationProps}.
+ */
+export type DynamicRealmProvider = React.FC<DynamicRealmProviderWithRealmProps | DynamicRealmProviderWithConfigurationProps>;
+export declare function createRealmProviderFromRealm(realm: Realm, RealmContext: React.Context<Realm | null>): RealmProviderFromRealm;
+/**
+ * Generates a `RealmProvider` given a {@link Realm.Configuration} and {@link React.Context}.
+ * @param realmConfig - The configuration of the Realm to be instantiated
+ * @param RealmContext - The context that will contain the Realm instance
+ * @returns a RealmProvider component that provides context to all context hooks
+ */
+export declare function createRealmProviderFromConfig(realmConfig: Realm.Configuration, RealmContext: React.Context<Realm | null>): RealmProviderFromConfiguration;
+/**
+ * Generates a `RealmProvider` which is either based on a configuration
+ * or based on a realm, depending on its props.
+ * @param RealmContext - The context that will contain the Realm instance
+ * @returns a RealmProvider component that provides context to all context hooks
+ */
+export declare function createDynamicRealmProvider(RealmContext: React.Context<Realm | null>): DynamicRealmProvider;
+/**
+ * Generates the appropriate `RealmProvider` based on whether there is a config, realm, or neither given.
+ * @param realmOrConfig - A Realm instance, a configuration, or undefined (including default provider).
+ * @param RealmContext - The context that will contain the Realm instance
+ * @returns a RealmProvider component that provides context to all context hooks
+ */
+export declare function createRealmProvider(realmOrConfig: Realm.Configuration | Realm | undefined, RealmContext: React.Context<Realm | null>): RealmProviderFromConfiguration | RealmProviderFromRealm | DynamicRealmProvider;
+/**
+ * Merge two configurations, creating a configuration using `configA` as the default,
+ * merged with `configB`, with properties in `configB` overriding `configA`.
+ * @param configA - The default config object
+ * @param configB - Config overrides object
+ * @returns Merged config object
+ */
+export declare function mergeRealmConfiguration(configA: PartialRealmConfiguration, configB: PartialRealmConfiguration): Realm.Configuration;
+/**
+ * Utility function that does a deep comparison (key: value) of object a with object b
+ * @param a - Object to compare
+ * @param b - Object to compare
+ * @returns True if the objects are identical
+ */
+export declare function areConfigurationsIdentical(a: Realm.Configuration, b: Realm.Configuration): boolean;
+export {};
+//# sourceMappingURL=RealmProvider.d.ts.map

package/dist/RealmProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RealmProvider.d.ts","sourceRoot":"","sources":["../src/RealmProvider.tsx"],"names":[],"mappings":"AAkBA,OAAO,KAAkD,MAAM,OAAO,CAAC;AACvE,OAAO,KAAK,MAAM,OAAO,CAAC;AAG1B,OAAO,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAE5C,KAAK,yBAAyB,GAAG,OAAO,CAAC,KAAK,CAAC,aAAa,CAAC,CAAC;AAE9D,MAAM,MAAM,qBAAqB,GAAG,KAAK,CAAC,aAAa,CAAC;AAExD,0DAA0D;AAC1D,KAAK,+BAA+B,GAAG;IACrC;;;OAGG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB;;;OAGG;IACH,QAAQ,CAAC,EAAE,KAAK,CAAC,gBAAgB,CAAC,KAAK,GAAG,IAAI,CAAC,CAAC;IAChD;;OAEG;IACH,QAAQ,CAAC,EAAE,qBAAqB,GAAG,KAAK,CAAC,aAAa,GAAG,KAAK,CAAC,YAAY,GAAG,IAAI,GAAG,SAAS,CAAC;IAC/F,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAC;CAC3B,GAAG,yBAAyB,CAAC;AAE9B,2DAA2D;AAC3D,KAAK,uBAAuB,GAAG;IAC7B;;OAEG;IACH,KAAK,EAAE,KAAK,CAAC;IACb,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAC;CAC3B,CAAC;AAEF,KAAK,kBAAkB,GAAG,+BAA+B,GAAG,uBAAuB,CAAC;AAEpF;;;;;GAKG;AACH,MAAM,MAAM,sBAAsB,GAAG,KAAK,CAAC,EAAE,CAAC,IAAI,CAAC,uBAAuB,EAAE,OAAO,CAAC,CAAC,CAAC;AAEtF;;GAEG;AACH,MAAM,MAAM,8BAA8B,GAAG,KAAK,CAAC,EAAE,CAAC,+BAA+B,CAAC,CAAC;AAEvF;;GAEG;AACH,MAAM,MAAM,kCAAkC,GAAG,eAAe,CAAC,kBAAkB,EAAE,MAAM,uBAAuB,CAAC,CAAC;AAEpH;;GAEG;AACH,MAAM,MAAM,0CAA0C,GAAG,eAAe,CACtE,kBAAkB,EAClB,MAAM,+BAA+B,CACtC,CAAC;AAEF;;;GAGG;AACH,MAAM,MAAM,oBAAoB,GAAG,KAAK,CAAC,EAAE,CACzC,kCAAkC,GAAG,0CAA0C,CAChF,CAAC;AAEF,wBAAgB,4BAA4B,CAC1C,KAAK,EAAE,KAAK,EACZ,YAAY,EAAE,KAAK,CAAC,OAAO,CAAC,KAAK,GAAG,IAAI,CAAC,GACxC,sBAAsB,CAIxB;AAED;;;;;GAKG;AACH,wBAAgB,6BAA6B,CAC3C,WAAW,EAAE,KAAK,CAAC,aAAa,EAChC,YAAY,EAAE,KAAK,CAAC,OAAO,CAAC,KAAK,GAAG,IAAI,CAAC,GACxC,8BAA8B,CA0EhC;AAED;;;;;GAKG;AACH,wBAAgB,0BAA0B,CAAC,YAAY,EAAE,KAAK,CAAC,OAAO,CAAC,KAAK,GAAG,IAAI,CAAC,GAAG,oBAAoB,CAY1G;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CACjC,aAAa,EAAE,KAAK,CAAC,aAAa,GAAG,KAAK,GAAG,SAAS,EACtD,YAAY,EAAE,KAAK,CAAC,OAAO,CAAC,KAAK,GAAG,IAAI,CAAC,GACxC,8BAA8B,GAAG,sBAAsB,GAAG,oBAAoB,CAQhF;AAED;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,yBAAyB,EAClC,OAAO,EAAE,yBAAyB,GACjC,KAAK,CAAC,aAAa,CAKrB;AAED;;;;;GAKG;AACH,wBAAgB,0BAA0B,CAAC,CAAC,EAAE,KAAK,CAAC,aAAa,EAAE,CAAC,EAAE,KAAK,CAAC,aAAa,GAAG,OAAO,CAElG"}

package/dist/cachedCollection.d.ts

@@ -0,0 +1,58 @@
+/// <reference types="react" />
+import Realm from "realm";
+/**
+ * Arguments object for {@link createCachedCollection}.
+ */
+type CachedCollectionArgs<T> = {
+    /**
+     * The {@link Realm.Collection} to proxy
+     */
+    collection: Realm.List<T> | Realm.Results<T>;
+    /**
+     * The {@link Realm} instance
+     */
+    realm: Realm;
+    /**
+     * Callback which is called whenever an object in the collection changes
+     */
+    updateCallback: () => void;
+    /**
+     * Reference boolean which is set to true whenever an object in the collection changes
+     * It is used to determine if the collection's object reference should be updated
+     * The implementing component should reset this to false when updating its object reference
+     */
+    updatedRef: React.MutableRefObject<boolean>;
+    /**
+     * Optional Map to be used as the cache. This is used to allow a `sorted` or `filtered`
+     * (derived) version of the collection to reuse the same cache, preventing excess new object
+     * references being created.
+     */
+    objectCache?: Map<string, T>;
+    /**
+     * Optional flag specifying that this is a derived (`sorted` or `filtered`) version of
+     * an existing collection, so we should not create or remove listeners or clear the cache
+     * when this is torn down.
+     */
+    isDerived?: boolean;
+    /**
+     * Optional list of key-paths to limit notifications.
+     */
+    keyPaths?: string[];
+};
+/**
+ * Creates a proxy around a {@link Realm.Collection} that will create new {@link Realm.Object}
+ * references on any relevant change (update, insert, deletion) and return the same
+ * object reference if no changes have occurred since the last access.
+ *
+ * This makes the {@link Realm.Collection} behaves in an immutable way, as React expects, so
+ * that a {@link Realm.Object} can be wrapped in {@link React.memo} to prevent unnecessary
+ * rendering (see {@link useQuery} hook).
+ * @param args {@link CachedCollectionArgs} object arguments
+ * @returns Proxy object wrapping the collection
+ */
+export declare function createCachedCollection<T extends Realm.Object<any>>({ collection, realm, updateCallback, updatedRef, objectCache, isDerived, keyPaths, }: CachedCollectionArgs<T>): {
+    collection: Realm.Results<T> | Realm.List<T>;
+    tearDown: () => void;
+};
+export {};
+//# sourceMappingURL=cachedCollection.d.ts.map

package/dist/cachedCollection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cachedCollection.d.ts","sourceRoot":"","sources":["../src/cachedCollection.ts"],"names":[],"mappings":";AAkBA,OAAO,KAAK,MAAM,OAAO,CAAC;AAU1B;;GAEG;AACH,KAAK,oBAAoB,CAAC,CAAC,IAAI;IAC7B;;OAEG;IACH,UAAU,EAAE,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;IAE7C;;OAEG;IACH,KAAK,EAAE,KAAK,CAAC;IAEb;;OAEG;IACH,cAAc,EAAE,MAAM,IAAI,CAAC;IAE3B;;;;OAIG;IACH,UAAU,EAAE,KAAK,CAAC,gBAAgB,CAAC,OAAO,CAAC,CAAC;IAE5C;;;;OAIG;IACH,WAAW,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC;IAE7B;;;;OAIG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;IAEpB;;OAEG;IACH,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;CACrB,CAAC;AAEF;;;;;;;;;;GAUG;AACH,wBAAgB,sBAAsB,CAAC,CAAC,SAAS,KAAK,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,EAClE,UAAU,EACV,KAAK,EACL,cAAc,EACd,UAAU,EACV,WAAuB,EACvB,SAAiB,EACjB,QAAQ,GACT,EAAE,oBAAoB,CAAC,CAAC,CAAC,GAAG;IAAE,UAAU,EAAE,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IAAC,QAAQ,EAAE,MAAM,IAAI,CAAA;CAAE,CAoHlG"}

package/dist/cachedObject.d.ts

@@ -0,0 +1,48 @@
+/// <reference types="react" />
+import Realm from "realm";
+/**
+ * Arguments object for `cachedObject`.
+ */
+type CachedObjectArgs = {
+    /**
+     * The {@link Realm.Object} to proxy
+     */
+    object: Realm.Object | null;
+    /**
+     * The {@link Realm} instance
+     */
+    realm: Realm;
+    /**
+     * Callback function called whenver the object changes. Used to force a component
+     * using the {@link useObject} hook to re-render.
+     */
+    updateCallback: () => void;
+    /**
+     * Reference boolean which is set to true whenever the object changes
+     * It is used to determine if the object's reference should be updated
+     * The implementing component should reset this to false when updating its object reference
+     */
+    updatedRef: React.MutableRefObject<boolean>;
+    /**
+     * Optional list of key-paths to limit notifications.
+     */
+    keyPaths?: string[];
+};
+export type CachedObject = {
+    object: Realm.Object | null;
+    tearDown: () => void;
+};
+/**
+ * Creates a proxy around a {@link Realm.Object} that will return a new reference
+ * on any relevant update to the object itself. It also wraps accesses to {@link Realm.List}
+ * attributes into a {@link cachedCollection}, so that any update, insert or deletion to the
+ * list will also return a new object reference.
+ *
+ * See {@link cachedCollection} and the `useObject` hook for description of how this
+ * helps prevent unnecessary rendering.
+ * @param args - {@link CachedObjectArgs} object arguments
+ * @returns Proxy object wrapping the {@link Realm.Object}
+ */
+export declare function createCachedObject({ object, realm, updateCallback, updatedRef, keyPaths, }: CachedObjectArgs): CachedObject;
+export {};
+//# sourceMappingURL=cachedObject.d.ts.map

package/dist/cachedObject.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cachedObject.d.ts","sourceRoot":"","sources":["../src/cachedObject.ts"],"names":[],"mappings":";AAkBA,OAAO,KAAK,MAAM,OAAO,CAAC;AAI1B;;GAEG;AACH,KAAK,gBAAgB,GAAG;IACtB;;OAEG;IACH,MAAM,EAAE,KAAK,CAAC,MAAM,GAAG,IAAI,CAAC;IAC5B;;OAEG;IACH,KAAK,EAAE,KAAK,CAAC;IACb;;;OAGG;IACH,cAAc,EAAE,MAAM,IAAI,CAAC;IAE3B;;;;OAIG;IACH,UAAU,EAAE,KAAK,CAAC,gBAAgB,CAAC,OAAO,CAAC,CAAC;IAE5C;;OAEG;IACH,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;CACrB,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG;IACzB,MAAM,EAAE,KAAK,CAAC,MAAM,GAAG,IAAI,CAAC;IAC5B,QAAQ,EAAE,MAAM,IAAI,CAAC;CACtB,CAAC;AAEF;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,CAAC,EACjC,MAAM,EACN,KAAK,EACL,cAAc,EACd,UAAU,EACV,QAAQ,GACT,EAAE,gBAAgB,GAAG,YAAY,CAwFjC"}