@ng-org/orm 0.1.2-alpha.1 → 0.1.2-alpha.10

package/dist/connector/ormSubscriptionHandler.js

@@ -0,0 +1,400 @@
+// Copyright (c) 2025 Laurin Weger, Par le Peuple, NextGraph.org developers
+// All rights reserved.
+// Licensed under the Apache License, Version 2.0
+// <LICENSE-APACHE2 or http://www.apache.org/licenses/LICENSE-2.0>
+// or the MIT license <LICENSE-MIT or http://opensource.org/licenses/MIT>,
+// at your option. All files in the project carrying such
+// notice may not be copied, modified, or distributed except
+// according to those terms.
+// SPDX-License-Identifier: Apache-2.0 OR MIT
+import { normalizeScope } from "../types.js";
+import { applyPatchesToDeepSignal } from "./applyPatches.js";
+import { ngSession } from "./initNg.js";
+import { deepSignal, watch as watchDeepSignal, batch, } from "@ng-org/alien-deepsignals";
+import { deepPatchesToWasm } from "./utils.js";
+/**
+ * Delay in ms to wait before closing subscription.\
+ * Useful when a hook unsubscribes and resubscribes in a short time interval
+ * so that no new subscriptions need to be set up.
+ */
+const WAIT_BEFORE_CLOSE = 500;
+/**
+ * Class for managing RDF-based ORM subscriptions with the engine.
+ *
+ * You have two options on how to interact with the ORM:
+ * - Use a hook for your favorite framework under `@ng-org/orm/react|vue|svelte`
+ * - Call {@link OrmSubscription.getOrCreate} to create a subscription manually
+ *
+ * For more information about RDF-based ORM subscriptions,
+ * see the README and follow the tutorial.
+ */
+export class OrmSubscription {
+    /** Global store of all subscriptions. We use that for pooling. */
+    static idToEntry = new Map();
+    /** The shape type that is subscribed to. */
+    shapeType;
+    /** The {@link Scope} of the subscription. */
+    scope;
+    /**
+     * The signalObject containing all data matching the shape and scope
+     * (once subscription is established).
+     * The object is of type {@link DeepSignalSet} which
+     * to the outside behaves like a regular set but has a couple of
+     * additional features:
+     * - Modifications are immediately propagated back to the database.
+     * - Database changes are immediately reflected in the object.
+     * - `.getBy(graphIri, subjectIri)` utility for quicker access to objects in set.
+     * - `.first()` utility to get the first element added to the set.
+     * - the iterator utilities, e.g. `.map()`, `.filter()`, ...
+     * - Watch for object changes using {@link watchDeepSignal}.
+     */
+    signalObject;
+    stopSignalListening;
+    /** The subscription ID kept as an identifier for communicating with the verifier. */
+    subscriptionId;
+    /** The number of OrmSubscriptions with the same shape and scope (for pooling). */
+    refCount;
+    /** Identifier as a combination of shape type and scope. Prevents duplications. */
+    identifier;
+    /** When true, modifications from the signalObject are not processed. */
+    suspendDeepWatcher;
+    /** True, if a transaction is running. */
+    inTransaction = false;
+    /** Aggregation of patches to be sent when in transaction. */
+    pendingPatches;
+    /** **Await to ensure that the subscription is established and the data arrived.** */
+    readyPromise;
+    closeOrmSubscription;
+    /** Function to call once initial data has been applied. */
+    resolveReady;
+    // FinalizationRegistry to clean up subscriptions when signal objects are GC'd.
+    static cleanupSignalRegistry = typeof FinalizationRegistry === "function"
+        ? new FinalizationRegistry((connectionId) => {
+            console.log("finalization called for", connectionId);
+            // Best-effort fallback; look up by id and clean
+            const entry = this.idToEntry.get(connectionId);
+            console.log("cleaning up connection", connectionId);
+            if (!entry)
+                return;
+            entry.close();
+        })
+        : null;
+    constructor(shapeType, scope) {
+        // @ts-expect-error
+        window.ormSignalConnections = OrmSubscription.idToEntry;
+        // @ts-expect-error
+        window.OrmSubscription = OrmSubscription;
+        this.shapeType = shapeType;
+        const normalizedScope = normalizeScope(scope);
+        this.scope = normalizedScope;
+        this.refCount = 1;
+        this.closeOrmSubscription = () => { };
+        this.suspendDeepWatcher = false;
+        this.identifier = `${shapeType.shape}|${canonicalScope(normalizedScope)}`;
+        this.signalObject = deepSignal(new Set(), {
+            propGenerator: this.signalObjectPropGenerator,
+            // Don't set syntheticIdPropertyName - let propGenerator handle all ID logic
+            readOnlyProps: ["@id", "@graph"],
+        });
+        // Schedule cleanup of the connection when the signal object is GC'd.
+        OrmSubscription.cleanupSignalRegistry?.register(this.signalObject, this.identifier, this.signalObject);
+        // Add listener to deep signal object to report changes back to wasm land.
+        const { stopListening } = watchDeepSignal(this.signalObject, this.onSignalObjectUpdate);
+        this.stopSignalListening = stopListening;
+        // Set promise to be resolved when data arrived from engine.
+        this.readyPromise = new Promise((resolve) => {
+            this.resolveReady = resolve;
+        });
+        ngSession.then(async ({ ng, session }) => {
+            try {
+                this.closeOrmSubscription = await ng.orm_start_graph(normalizedScope.graphs, normalizedScope.subjects, shapeType, session.session_id, this.onBackendMessage);
+            }
+            catch (e) {
+                console.error(e);
+            }
+        });
+    }
+    /**
+     * Returns an OrmSubscription which subscribes to the given
+     * {@link ShapeType} and {@link Scope} in a 2-way binding.
+     *
+     * You **find the data** and objects matching the shape and scope
+     * in the **`signalObject`** once {@link readyPromise} resolves. This is a {@link DeepSignalSet} which
+     * to the outside behaves like a regular set but has a couple of
+     * additional features:
+     * - Modifications are propagated back to the database.
+     *   Note that multiple immediate modifications in the same task,
+     *   e.g. `obj[0] = "foo"; obj[1] = "bar"` are batched together
+     *   and sent in a subsequent microtask.
+     * - Database changes are immediately reflected in the object.
+     * - `.getBy(graphIri, subjectIri)` utility for quicker access to objects in set.
+     * - `.first()` utility to get the first element added to the set.
+     * - the iterator utilities, e.g. `.map()`, `.filter()`, ...
+     * - Watch for object changes using {@link watchDeepSignal}.
+     *
+     * You can use **transactions**, to prevent excessive calls to the database
+     * with {@link beginTransaction} and {@link commitTransaction}.
+     *
+     * In many cases, you are advised to use a hook for your
+     * favorite framework under `@ng-org/orm/react|vue|svelte`
+     * instead of calling `getOrCreate` directly.
+     *
+     * Call {@link close}, to close the subscription.
+     *
+     * Note: If another call to `getOrCreate` was previously made
+     * and `close` was not called on it (or only shortly after),
+     * it will return the same OrmSubscription.
+     *
+     * @param shapeType The {@link ShapeType}
+     * @param scope The {@link Scope}. If no scope is given, the whole store is considered.
+     *
+     * @example
+     * ```typescript
+     * // We assume you have created a graph document already, as below.
+     * // const documentId = await ng.doc_create(
+     * //     session_id,
+     * //     "Graph",
+     * //     "data:graph",
+     * //     "store",
+     * //     undefined
+     * // );
+     * const subscription = OrmSubscription.getOrCreate(ExpenseShapeType, {graphs: [graphIri]});
+     * // Wait for data.
+     * await subscription.readyPromise;
+     *
+     * const expense = subscription.signalObject.first()
+     * expense.name = "updated name";
+     * expense.description = "updated description";
+     *
+     * // Await promise to run the below code in a new task.
+     * // That will push the changes to the database.
+     * await Promise.resolve();
+     *
+     * // Here, the expense modifications have been have been committed
+     * // (unless you had previously called subscription.beginTransaction()).
+     * // The data is available in subscriptions running on a different device too.
+     *
+     * subscription.close();
+     * // If you create a new subscription with the same document within a couple of 100ms,
+     * // The subscription hasn't been closed and the old one is returned so that the data
+     * // is available instantly. This is especially useful in the context of frontend frameworks.
+     * const subscription2 = OrmSubscription.getOrCreate(ExpenseShapeType, {graphs: [graphIri]});
+     *
+     * subscription2.signalObject.add({
+     *    "@graph": graphIri,
+     *    "@id": "", // Leave empty to auto-assign one.
+     *    name": "A new expense",
+     *    description: "A new description"
+     * });
+     *
+     * subscription2.close()
+     * ```
+     */
+    static getOrCreate = (shapeType, scope) => {
+        const scopeKey = canonicalScope(scope);
+        // Unique identifier for a given shape type and scope.
+        const identifier = `${shapeType.shape}|${scopeKey}`;
+        // If we already have an object for this shape+scope,
+        // return it and just increase the reference count.
+        // Otherwise, create new one.
+        const existingConnection = OrmSubscription.idToEntry.get(identifier);
+        if (existingConnection) {
+            existingConnection.refCount += 1;
+            return existingConnection;
+        }
+        else {
+            const newConnection = new OrmSubscription(shapeType, scope);
+            OrmSubscription.idToEntry.set(identifier, newConnection);
+            return newConnection;
+        }
+    };
+    /**
+     * Stop the subscription.
+     *
+     * **If there is more than one subscription with the same shape type and scope
+     * the orm subscription will persist.**
+     *
+     * Additionally, the closing of the subscription is delayed by a couple hundred milliseconds
+     * so that when frontend frameworks unmount and soon mount a component again with the same
+     * shape type and scope,  we reuse the same orm subscription.
+     */
+    close = () => {
+        setTimeout(() => {
+            if (this.refCount > 0)
+                this.refCount--;
+            if (this.refCount === 0) {
+                OrmSubscription.idToEntry.delete(this.identifier);
+                OrmSubscription.cleanupSignalRegistry?.unregister(this.signalObject);
+                this.closeOrmSubscription();
+            }
+        }, WAIT_BEFORE_CLOSE);
+    };
+    /** Handle updates (patches) coming from signal object modifications. */
+    onSignalObjectUpdate = async ({ patches }) => {
+        if (this.suspendDeepWatcher || !patches.length)
+            return;
+        const ormPatches = deepPatchesToWasm(patches);
+        // If in transaction, collect patches immediately (no await before).
+        if (this.inTransaction) {
+            this.pendingPatches?.push(...ormPatches);
+            return;
+        }
+        // Wait for session and subscription to be initialized.
+        const { ng, session } = await ngSession;
+        await this.readyPromise;
+        ng.graph_orm_update(this.subscriptionId, ormPatches, session.session_id);
+    };
+    /** Handle messages coming from the engine (initial data or patches). */
+    onBackendMessage = (message) => {
+        const data = message?.V0;
+        if (data?.GraphOrmInitial) {
+            this.handleInitialResponse(data.GraphOrmInitial);
+        }
+        else if (data?.GraphOrmUpdate) {
+            this.onBackendUpdate(data.GraphOrmUpdate);
+        }
+        else {
+            console.warn("Received unknown ORM message from engine", message);
+        }
+    };
+    handleInitialResponse = ([initialData, subscriptionId]) => {
+        this.subscriptionId = subscriptionId;
+        // Assign initial data to empty signal object without triggering watcher at first.
+        this.suspendDeepWatcher = true;
+        batch(() => {
+            // Note: Instead, we await for the connection to be initialized and send patches after. So no need to remove.
+            // // Do this in case the there was any (incorrect) data added before initialization.
+            // this.signalObject.clear();
+            // Convert arrays to sets and apply to signalObject (we only have sets but can only transport arrays).
+            for (const newItem of parseOrmInitialObject(initialData)) {
+                this.signalObject.add(newItem);
+            }
+        });
+        queueMicrotask(() => {
+            this.suspendDeepWatcher = false;
+            // Resolve readiness after initial data is committed and watcher armed.
+            this.resolveReady();
+        });
+    };
+    /** Handle incoming patches from the engine */
+    onBackendUpdate = (patches) => {
+        this.suspendDeepWatcher = true;
+        applyPatchesToDeepSignal(this.signalObject, patches, "set");
+        // Use queueMicrotask to ensure watcher is re-enabled _after_ batch completes
+        queueMicrotask(() => {
+            this.suspendDeepWatcher = false;
+        });
+    };
+    /** Function to create random subject NURIs for newly created nested objects. */
+    signalObjectPropGenerator = ({ path, object, }) => {
+        let graphIri = undefined;
+        let subjectIri = undefined;
+        // If no @graph is set, add the parent's graph NURI. If there is no parent, throw.
+        if (!object["@graph"] || object["@graph"] === "") {
+            if (path.length > 1) {
+                // The first part of the path is the <graphNuri>|<subjectIri> composition.
+                graphIri = path[0].split("|")[0];
+            }
+            else {
+                throw new Error("When adding new root orm objects, you must specify the @graph");
+            }
+        }
+        else {
+            graphIri = object["@graph"];
+        }
+        if (object["@id"] && object["@id"] !== "") {
+            subjectIri = object["@id"];
+        }
+        else {
+            // Generate 33 random bytes using Web Crypto API
+            const b = new Uint8Array(33);
+            crypto.getRandomValues(b);
+            // Convert to base64url
+            const base64url = (bytes) => btoa(String.fromCharCode(...bytes))
+                .replace(/\+/g, "-")
+                .replace(/\//g, "_")
+                .replace(/=+$/, "");
+            const randomString = base64url(b);
+            // We use the root subject's graph as the basis.
+            // TODO: We could use the closest parent's graph instead.
+            subjectIri =
+                (path[0] ?? graphIri).substring(0, 9 + 44) +
+                    ":q:" +
+                    randomString;
+        }
+        return {
+            extraProps: { "@id": subjectIri, "@graph": graphIri },
+            syntheticId: graphIri + "|" + subjectIri,
+        };
+    };
+    /**
+     * Begins a transaction that batches changes to be committed to the database.
+     * This is useful for performance reasons.
+     *
+     * Note that this does not disable reactivity of the `signalObject`.
+     * Modifications keep being rendered.
+     */
+    beginTransaction = () => {
+        this.inTransaction = true;
+        this.pendingPatches = [];
+        // Use a listener that immediately triggers on object modifications.
+        // We don't need the deep-signal's batching (through microtasks) here.
+        this.stopSignalListening();
+        const { stopListening } = watchDeepSignal(this.signalObject, this.onSignalObjectUpdate, { triggerInstantly: true });
+        this.stopSignalListening = stopListening;
+    };
+    /**
+     * Commits a transactions sending all modifications made during the transaction
+     * (started with `beginTransaction`) to the database.
+     */
+    commitTransaction = async () => {
+        if (!this.inTransaction) {
+            throw new Error("No transaction is open. Call `beginTransaction` first.");
+        }
+        const { ng, session } = await ngSession;
+        await this.readyPromise;
+        this.inTransaction = false;
+        if (this.pendingPatches?.length == 0) {
+            // Nothing to send to the engine.
+        }
+        else {
+            // Send patches to engine.
+            await ng.graph_orm_update(this.subscriptionId, this.pendingPatches, session.session_id);
+        }
+        this.pendingPatches = undefined;
+        // Go back to the regular object modification listening where we want batching
+        // scheduled in a microtask only triggered after the main task.
+        // This way we prevent excessive calls to the engine.
+        this.stopSignalListening();
+        const { stopListening } = watchDeepSignal(this.signalObject, this.onSignalObjectUpdate);
+        this.stopSignalListening = stopListening;
+    };
+}
+const parseOrmInitialObject = (obj) => {
+    // Regular arrays become sets.
+    if (Array.isArray(obj)) {
+        return new Set(obj.map(parseOrmInitialObject));
+    }
+    else if (obj && typeof obj === "object") {
+        if ("@id" in obj) {
+            // Regular object.
+            for (const key of Object.keys(obj)) {
+                obj[key] = parseOrmInitialObject(obj[key]);
+            }
+        }
+        else {
+            // Object does not have @id, that means it's a set of objects.
+            return new Set(Object.values(obj).map(parseOrmInitialObject));
+        }
+    }
+    return obj;
+};
+/**
+ * Creates a string out of the scope in the format
+ * `graphIri1,graphIri2|subjectIri1,subjectIri2`
+ */
+function canonicalScope(scope) {
+    if (!scope)
+        return "";
+    return `${(scope.graphs || []).slice().sort().join(",")}|${(scope.subjects || []).slice().sort().join(",")}`;
+}

package/dist/connector/utils.d.ts

@@ -0,0 +1,17 @@
+import type { DeepPatch } from "@ng-org/alien-deepsignals";
+import { Patch } from "./applyPatches.ts";
+/**
+ * Deep clone function with support for Sets and Maps.
+ * Function generated by Claude Opus 4.5
+ * @ignore
+ */
+export declare const deepClone: <T>(object: T, seen?: WeakMap<WeakKey, any>) => T;
+/**
+ * Converts DeepSignal patches to ORM Wasm-compatible patches
+ * @param patches DeepSignal patches
+ * @returns Patches with stringified path
+ *
+ * @ignore
+ */
+export declare function deepPatchesToWasm(patches: DeepPatch[]): Patch[];
+//# sourceMappingURL=utils.d.ts.map

package/dist/connector/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/connector/utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAC;AAC3D,OAAO,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAC;AAE1C;;;;GAIG;AACH,eAAO,MAAM,SAAS,GAAI,CAAC,EAAE,QAAQ,CAAC,EAAE,4BAAoB,KAAG,CAwD9D,CAAC;AAEF;;;;;;GAMG;AAEH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,SAAS,EAAE,GAAG,KAAK,EAAE,CAO/D"}

package/dist/connector/utils.js

@@ -0,0 +1,68 @@
+/**
+ * Deep clone function with support for Sets and Maps.
+ * Function generated by Claude Opus 4.5
+ * @ignore
+ */
+export const deepClone = (object, seen = new WeakMap()) => {
+    // Handle primitives and null
+    if (object === null || typeof object !== "object") {
+        return object;
+    }
+    // Handle circular references
+    if (seen.has(object)) {
+        return seen.get(object);
+    }
+    // Handle Date
+    if (object instanceof Date) {
+        return new Date(object.getTime());
+    }
+    // Handle Set
+    if (object instanceof Set) {
+        const clonedSet = new Set();
+        seen.set(object, clonedSet);
+        for (const item of object) {
+            clonedSet.add(deepClone(item, seen));
+        }
+        return clonedSet;
+    }
+    // Handle Map
+    if (object instanceof Map) {
+        const clonedMap = new Map();
+        seen.set(object, clonedMap);
+        for (const [key, value] of object) {
+            clonedMap.set(deepClone(key, seen), deepClone(value, seen));
+        }
+        return clonedMap;
+    }
+    // Handle Array
+    if (Array.isArray(object)) {
+        const clonedArray = [];
+        seen.set(object, clonedArray);
+        for (const item of object) {
+            clonedArray.push(deepClone(item, seen));
+        }
+        return clonedArray;
+    }
+    // Handle plain objects
+    const clonedObject = {};
+    seen.set(object, clonedObject);
+    for (const key of Object.keys(object)) {
+        clonedObject[key] = deepClone(object[key], seen);
+    }
+    return clonedObject;
+};
+/**
+ * Converts DeepSignal patches to ORM Wasm-compatible patches
+ * @param patches DeepSignal patches
+ * @returns Patches with stringified path
+ *
+ * @ignore
+ */
+export function deepPatchesToWasm(patches) {
+    return patches.flatMap((patch) => {
+        if (patch.op === "add" && patch.type === "set" && !patch.value?.length)
+            return [];
+        const path = "/" + patch.path.join("/");
+        return { ...patch, path };
+    });
+}

package/dist/frontendAdapters/react/index.d.ts

@@ -1,3 +1,4 @@
 import useShape from "./useShape.ts";
-export { useShape };
+import { useDiscrete } from "./useDiscrete.ts";
+export { useShape, useDiscrete };
 //# sourceMappingURL=index.d.ts.map

package/dist/frontendAdapters/react/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/frontendAdapters/react/index.ts"],"names":[],"mappings":"AAAA,OAAO,QAAQ,MAAM,eAAe,CAAC;AACrC,OAAO,EAAE,QAAQ,EAAE,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/frontendAdapters/react/index.ts"],"names":[],"mappings":"AAAA,OAAO,QAAQ,MAAM,eAAe,CAAC;AACrC,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAC/C,OAAO,EAAE,QAAQ,EAAE,WAAW,EAAE,CAAC"}

package/dist/frontendAdapters/react/index.js

@@ -1,2 +1,3 @@
 import useShape from "./useShape.js";
-export { useShape };
+import { useDiscrete } from "./useDiscrete.js";
+export { useShape, useDiscrete };

package/dist/frontendAdapters/react/useDiscrete.d.ts

@@ -0,0 +1,104 @@
+import { DeepSignal } from "@ng-org/alien-deepsignals";
+import { DiscreteRoot } from "../../types.ts";
+/**
+ * Hook to subscribe to an existing discrete (JSON) CRDT document.
+ * You can modify the returned object like any other JSON object. Changes are immediately
+ * reflected in the CRDT document.
+ *
+ * Establishes a 2-way binding: Modifications to the object are immediately committed;
+ * changes coming from the engine (or other components) cause an immediate rerender.
+ *
+ * In comparison to {@link reactUseShape}, discrete CRDTs are untyped.
+ * You can put any JSON data inside and need to validate the schema yourself.
+ *
+ * @param documentId The NURI of the CRDT document.
+ * @returns An object that contains as `doc` the reactive DeepSignal object or undefined if `documentId` is undefined.
+ *
+ * @example
+ * ```tsx
+ * // We assume you have created a CRDT document already, as below.
+ * // const documentId = await ng.doc_create(
+ * //     session_id,
+ * //     crdt, // "Automerge" | "YMap" | "YArray". YArray is for root arrays, the other two have objects at root.
+ * //     crdt === "Automerge" ? "data:json" : crdt === "YMap ? "data:map" : "data:array",
+ * //     "store",
+ * //     undefined
+ * // );
+ *
+ * function Expenses({documentId}: {documentId: string}) {
+ *     const { doc } = useDiscrete(documentId);
+ *
+ *     // If the CRDT document is still empty, we need to initialize it.
+ *     if (doc && !doc.expenses) {
+ *         doc.expenses = [];
+ *     }
+ *     const expenses = doc?.expenses;
+ *
+ *     const createExpense = useCallback(() => {
+ *             // Note that we use *expense["@id"]* as a key in the expense list.
+ *             // Every object added to a CRDT array gets a stable `@id` property assigned
+ *             // which you can use for referencing objects in arrays even as
+ *             // objects are removed or added from the array.
+ *             // The `@id` is a NURI with the schema `<documentId>:d:<object-specific id>`.
+ *             // Since the `@id` is generated in the engine, the object is
+ *             // *preliminarily given a mock id* which will be replaced immediately.
+ *             expenses.push({
+ *                 title: "New expense",
+ *                 date: new Date().toISOString(),
+ *             });
+ *         },
+ *         [expenses]
+ *     );
+ *
+ *     // Still loading?
+ *     if (!doc) return <div>Loading...</div>;
+ *
+ *     return (
+ *         <div>
+ *             <button
+ *                 onClick={() => createExpense()}
+ *             >
+ *                 + Add expense
+ *             </button>
+ *             <div>
+ *                 {expenses.length === 0 ? (
+ *                     <p>
+ *                         No expenses yet.
+ *                     </p>
+ *                 ) : (
+ *                     expenses.map((expense) => (
+ *                         <ExpenseCard
+ *                             key={expense["@id"]}
+ *                             expense={expense}
+ *                         />
+ *                     ))
+ *                 )}
+ *             </div>
+ *         </div>
+ *     );
+ * }
+ * ```
+ *
+ * ---
+ * In the ExpenseCard component:
+ * ```tsx
+ * function ExpenseCard({expense}: {expense: Expense}) {
+ *    return (
+ *        <input
+ *            value={expense.title}
+ *            onChange={(e) => {
+ *                expense.title = e.target.value; // Changes trigger rerender.
+ *            }}
+ *        />
+ *        <div>
+ *            <p>Date</p>
+ *            <p>{expense.doc}
+ *        </div
+ *    );
+ * }
+ * ```
+ */
+export declare function useDiscrete<T extends DiscreteRoot = DiscreteRoot>(documentId: string | undefined): {
+    doc: DeepSignal<T> | undefined;
+};
+//# sourceMappingURL=useDiscrete.d.ts.map

package/dist/frontendAdapters/react/useDiscrete.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDiscrete.d.ts","sourceRoot":"","sources":["../../../src/frontendAdapters/react/useDiscrete.ts"],"names":[],"mappings":"AAaA,OAAO,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAC;AACvD,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAI9C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiGG;AAEH,wBAAgB,WAAW,CAAC,CAAC,SAAS,YAAY,GAAG,YAAY,EAC7D,UAAU,EAAE,MAAM,GAAG,SAAS;;EAsDjC"}