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

package/README.md

@@ -1,44 +1,45 @@
-# @ng-org/orm
+# NextGraph ORM SDK
 
-Reactive ORM library for NextGraph — use typed, reactive objects that automatically sync to NextGraph's encrypted, local-first storage.
+Reactive ORM library for NextGraph: use reactive (typed) objects that automatically sync to NextGraph's encrypted, local-first storage.
 
-For a walk-through, you can see the the [expense-tracker example app](https://git.nextgraph.org/NextGraph/expense-tracker) which shows
-- React, Vue, and Svelte frontends sharing data
-- SHEX schema definitions
-- CRUD operations
-- Cross-framework real-time sync
+For a walk-through you can see the the expense-tracker example apps for [discrete JSON documents](https://git.nextgraph.org/NextGraph/expense-tracker-discrete) or [typed graph documents](https://git.nextgraph.org/NextGraph/expense-tracker-graph).
+
+## Reference documentation
+
+[Reference documentation is available here on docs.nextgraph.org](https://docs.nextgraph.org/en/reference/orm/).
+
+## Why?
+
+Different CRDTs have different APIs. We want to make it as easy as possible to use them in the same way:\
+**You modify a plain old TypeScript object and that updates the CRDT.**\
+Vice versa, the CRDT is modified and that is reflected in your TS object.\
+We offer this for **React, Vue, and Svelte**.
+
+Note that we support discrete (**JSON**) CRDT and graph (**RDF**) CRDT ORMs.
+
+- For graphs, you specify a schema using a SHEX shape and optionally a scope. This provides you with typing support.
+- For discrete CRDTs, all you need is a document ID (NURI).
 
 ## Table of Contents
 
-- [@ng-org/orm](#ng-orgorm)
-  - [Table of Contents](#table-of-contents)
-  - [Installation](#installation)
-  - [Quick Start](#quick-start)
-  - [Defining Schemas](#defining-schemas)
-  - [Framework Usage](#framework-usage)
-    - [React](#react)
-    - [Vue](#vue)
-    - [Svelte](#svelte)
-  - [Working with Data](#working-with-data)
-    - [Adding Objects](#adding-objects)
-    - [Modifying Objects](#modifying-objects)
-    - [Deleting Objects](#deleting-objects)
-    - [Working with Sets](#working-with-sets)
-    - [Relationships](#relationships)
-  - [API Reference](#api-reference)
-    - [`useShape(shapeType)`](#useshapeshapetype)
-    - [Shared State](#shared-state)
-  - [License](#license)
+- [Installation](#installation)
+- [Start](#start)
+- [Graph ORM: Defining Schemas](#graph-orm-defining-schemas)
+- [Frontend Framework Usage](#frontend-framework-usage)
+- [Working with Data](#working-with-data)
+    - [Creating a Document](#creating-a-document)
+    - [Using and Modifying ORM Objects](#using-and-modifying-orm-objects)
+        - [Graph ORM: Relationships](#graph-orm-relationships)
 
 ---
 
 ## Installation
 
 ```bash
-pnpm add @ng-org/orm @ng-org/web @ng-org/alien-deepsignals
+pnpm add @ng-org/orm @ng-org/web
 ```
 
-For schema code generation, also install:
+For schema generation, also install:
 
 ```bash
 pnpm add -D @ng-org/shex-orm
@@ -46,7 +47,9 @@ pnpm add -D @ng-org/shex-orm
 
 ---
 
-## Quick Start
+## Start
+
+You are strongly advised to look at the example apps for [discrete JSON documents](https://git.nextgraph.org/NextGraph/expense-tracker-discrete) and [typed graph documents](https://git.nextgraph.org/NextGraph/expense-tracker-graph).
 
 Before using the ORM, initialize NextGraph in your app entry point:
 
@@ -56,6 +59,7 @@ import { initNg } from "@ng-org/orm";
 
 await init(
     async (event) => {
+        // The ORM needs to have access to ng, the interface to the engine running in WASM.
         initNg(ng, event.session);
     },
     true,
@@ -63,27 +67,25 @@ await init(
 );
 ```
 
-Then use `useShape()` in your components:
+Then use `useShape()` for graphs, or `useDiscrete()` for discrete documents.
 
-```typescript
-import { useShape } from "@ng-org/orm/react";  // or /vue, /svelte
-import { DogShapeType } from "./shapes/orm/dogShape.shapeTypes";
+In some cases, you may want to use advanced features managing subscriptions with the engine.
+With an OrmSubscription, you can manage things like transactions manually.
+This is useful for example when you want to manage a state across components.
+See [`OrmSubscription.getOrCreate(ShapeType, scope)`](#getorcreate-1) for graphs
+and [`DiscreteOrmSubscription.getOrCreate(documentId)`](#getorcreate) for discrete documents.
 
-const dogs = useShape(DogShapeType);
+Internally, the OrmSubscription keeps a signalObject, a proxied, reactive object. When modifications are made, this makes the frontend components rerender and sends the update to the engine to be persisted.
 
-// Iterate, modify, add — changes auto-sync everywhere
-for (const dog of dogs) {
-    console.log(dog.name);
-}
-```
+In all cases, you have to create a document first with `ng.doc_create()`.
 
----
-
-## Defining Schemas
+## Graph ORM: Defining Schemas
 
 Define your data model using [SHEX (Shape Expressions)](https://shex.io/):
+See [@ng-org/shex-orm](../shex-orm/README.md) for details.
 
 **`shapes/shex/dogShape.shex`**:
+
 ```shex
 PREFIX ex: <http://example.org/>
 PREFIX xsd: <http://www.w3.org/2001/XMLSchema#>
@@ -99,237 +101,156 @@ ex:Dog {
 Generate TypeScript types. Add the following to your `package.json` scripts and run `build:orm`:
 
 ```json
-    "build:orm": "rdf-orm build --input ./src/shapes/shex --output ./src/shapes/orm"
+"build:orm": "rdf-orm build --input ./src/shapes/shex --output ./src/shapes/orm"
 ```
 
-This creates:
-- `dogShape.typings.ts` — TypeScript interfaces
-- `dogShape.shapeTypes.ts` — Shape type objects for `useShape()`
-- `dogShape.schema.ts` — Internal schema metadata
-
-See [@ng-org/shex-orm](../shex-orm/README.md) for full documentation.
-
----
-
-## Framework Usage
-
-### React
-
-```tsx
-import { useShape } from "@ng-org/orm/react";
-import { DogShapeType } from "./shapes/orm/dogShape.shapeTypes";
-import type { Dog } from "./shapes/orm/dogShape.typings";
-
-export function DogList() {
-    const dogs = useShape(DogShapeType);  // DeepSignalSet<Dog>
-
-    return (
-        <ul>
-            {[...dogs].map(dog => (
-                <li key={dog["@id"]}>
-                    {/* Direct mutation triggers re-render */}
-                    <input
-                        value={dog.name}
-                        onChange={e => dog.name = e.target.value}
-                    />
-                </li>
-            ))}
-        </ul>
-    );
-}
-```
-
-> **Note**: No `setState` needed — just mutate the object directly.
-
-### Vue
-
-**Parent component** (`DogList.vue`):
-```vue
-<script setup lang="ts">
-import { useShape } from "@ng-org/orm/vue";
-import { DogShapeType } from "./shapes/orm/dogShape.shapeTypes";
-import DogCard from "./DogCard.vue";
-
-const dogs = useShape(DogShapeType);  // DeepSignalSet<Dog>
-</script>
-
-<template>
-    <DogCard
-        v-for="dog in dogs"
-        :key="dog['@id']"
-        :dog="dog"
-    />
-</template>
-```
-
-**Child component** (`DogCard.vue`):
-```vue
-<script setup lang="ts">
-import { useDeepSignal } from "@ng-org/alien-deepsignals/vue";
-import type { Dog } from "./shapes/orm/dogShape.typings";
-
-const props = defineProps<{ dog: Dog }>();
-
-// Required for reactivity in child components!
-const dog = useDeepSignal(props.dog);
-</script>
-
-<template>
-    <div>
-        <input v-model="dog.name" />
-    </div>
-</template>
-```
-
-> **Important**: In Vue child components, wrap props with `useDeepSignal()` to enable reactivity.
-
-### Svelte
-
-```svelte
-<script lang="ts">
-import { useShape } from "@ng-org/orm/svelte";
-import { DogShapeType } from "./shapes/orm/dogShape.shapeTypes";
-
-const dogs = useShape(DogShapeType);  // Reactive store
-</script>
+## Frontend Framework Usage
+
+The SDK offers hooks for discrete and graph-based CRDTs for Svelte, Vue and React:
+
+- discrete CRDTs for
+    - Svelte 5: [useDiscrete](#svelteusediscrete)
+    - Svelte 3/4: [useDiscrete](#svelte4usediscrete)
+    - Vue: [useDiscrete](#vueusediscrete)
+    - React: [useDiscrete](#reactusediscrete)
+- graph CRDTs for:
+    - Svelte 5: [useShape](#svelteuseshape)
+    - Svelte 3/4: [useShape](#svelte4useshape)
+    - Vue: [useShape](#vueuseshape)
+    - React: [useShape](#reactuseshape)
+
+All of them have the same logic. They create a 2-way binding to the engine.
+You can modify the returned object like any other JSON object. Changes are immediately
+reflected in the CRDT and the components rerender.
+When the component unmounts, the subscription is closed.
+
+```ts
+// Queries the graphs with NURI did:ng:o:g1 and did:ng:o:g2 and with subject s1 or s2.
+const expenses: DeepSignal<Set<Expense>> = useShape(ExpenseShapeType, {
+    graphs: ["did:ng:o:g1", "did:ng:o:g2"],
+    subjects: ["<s1 IRI>", "<s2 IRI>"],
+});
 
-<ul>
-    {#each [...$dogs] as dog (dog['@id'])}
-        <li>
-            <input bind:value={dog.name} />
-        </li>
-    {/each}
-</ul>
+// Use expenses in your component
+// and modify them to trigger a rerender and persist them.
+// ...
 ```
 
-> **Note**: Access the store value with `$dogs`. Standard Svelte binding works.
-
 ---
 
 ## Working with Data
 
-### Adding Objects
+The ORM is designed to make working with data as normal as possible.
+You get an object as you are used to it and when you change properties,
+they are automatically persisted and synced with other devices. Conversely,
+modifications arrive at the ORM objects immediately and your components rerender.
 
-To add a new object, you need a document IRI (`@graph`). Create a document first:
+### Creating a Document
 
-```typescript
-import { sessionPromise } from "./utils/ngSession";
-
-const session = await sessionPromise;
+First, you need a document to store and get your data.
+With the document NURI, you can then create ORM objects.
 
+```ts
 // Create a new NextGraph document
-const docIri = await session.ng.doc_create(
-    session.session_id,
-    "Graph",
-    "data:graph",
+const docNuri = await ng.doc_create(
+    session_id,
+    "Graph", // Or "YMap" or "Automerge", for discrete
+    "data:graph", // Or "data:json" : "data:map" for Automerge or YJs
     "store",
     undefined
 );
 
-// Add to the reactive set
-dogs.add({
-    "@graph": docIri,                   // Required: document IRI
-    "@type": "http://example.org/Dog",  // Required: RDF type
-    "@id": "",                          // Empty = auto-generate subject IRI
-    name: "Buddy",
-    age: 3,
-    toys: new Set(["ball", "rope"]),
-});
+// Add class to RDF part of the document so we can find it again.
+await ng.sparql_update(
+    session_id,
+    `INSERT DATA { GRAPH <${documentId}> {<${documentId}> a <${APPLICATION_CLASS_IRI}> } }`,
+    documentId
+);
 ```
 
-> **Note**: For nested sub-objects, `@graph` is optional — the parent's graph IRI is used.
->
-> **Note**: If you want to use the ORM signal object in a non-component context, you can use `createSignalObjectForShape` function as well.
-
-### Modifying Objects
+To find your document, you can make a sparql query as well:
 
-Simply assign new values:
-
-```typescript
-dog.name = "Max";
-dog.age = 4;
+```ts
+const ret = await ng.sparql_query(
+    session_id,
+    `SELECT ?storeId WHERE { GRAPH ?storeId { ?s a <${APPLICATION_CLASS_IRI}> } }`,
+    undefined,
+    undefined
+);
+let documentId = ret?.results.bindings?.[0]?.storeId?.value;
 ```
 
-Changes are:
-- Immediately reflected in all components using the same shape
-- Automatically persisted to NextGraph storage
-- Synced to other devices in real-time
-
-### Deleting Objects
+### Using and Modifying ORM Objects
 
-```typescript
-dogs.delete(dog);
-```
+There are multiple ways to get and modify data:
 
-### Working with Sets
-
-Properties with SHEX cardinality `*` or `+` become reactive Sets:
+- Get and modify the data returned by a `useShape()` or `useDiscrete()` hook inside a component.
+- Get and modify the signalObject of the subscription returned by `Orm(Discrete)Subscription.getOrCreate()`.
+- For graph ORMs: Call [`insertObject()`](#insertobject) or [`getObjects`](#getobjects) (no 2-way binding).
 
 ```typescript
-// Add items
-dog.toys.add("frisbee");
+const dogSubscription = OrmSubscription.getOrCreate(DogShape, {
+    graphs: [docNuri],
+});
+await dogSubscription.readyPromise;
 
-// Remove items
-dog.toys.delete("ball");
+// If we used OrmDiscreteSubscription, the signalObject type would be array or object.
+const dogSet: DeepSignal<Set<Dog>> = dogSubscription.signalObject;
 
-// Check membership
-if (dog.toys.has("rope")) { ... }
+dogs.add({
+    // Required: The document NURI. May be set to `""` for nested objects (will be inherited from parent object then).
+    "@graph": docNuri,
+    "@type": "did:ng:x:Dog", // Required: RDF type
+    "@id": "", // Empty string = auto-generate subject IRI
+    name: "Mr Puppy",
+    age: 2,
+    toys: new Set(["ball", "rope"]),
+});
 
-// Iterate
-for (const toy of dog.toys) {
-    console.log(toy);
-}
+// When you know that only one element is in the set, you can call `.first()` to get it.
+const aDog = dogs.first();
+aDog.age += 1;
+aDog.toy.add("bone");
 
-// Get size
-console.log(dog.toys.size);
+// Utility to find objects in sets:
+const sameDog = dogs.getBy(aDog["@graph"], aDog["@id"]);
+// sameSog === aDog.
 
-// NOTE: For ES2025 environment, set iterator objects are directly attached:
-dogs.forEach((dog) => {
-    console.log(dog.toys.size);
-});
+dogs.delete(aDog);
 ```
 
-### Relationships
+Note that the graph CRDT supports sets only, the discrete CRDTs arrays only.
 
-Link objects by storing the target's `@id` IRI:
+#### Graph ORM: Relationships
+
+To reference external objects, you can use their `@id`.
 
 ```typescript
-// In your SHEX schema:
-// ex:owner IRI ;
+casey.friends.add(jackNuri);
 
-// Link to another object
-dog.owner = person["@id"];
+// When the child object is a nested object that you do not have in memory,
+// you can establish the link by adding an object that contains the `@id` property only.
+shoppingExpense.category.add({ "@id": "<Subject IRI of expense category>" });
+// Link objects by storing the target's `@id` NURI/IRI:
 
+dog.owner = jackNuri;
 // Resolve the relationship
-const owner = people.find(p => p["@id"] === dog.owner);
-```
-
----
-
-## API Reference
-
-### `useShape(shapeType)`
-
-Returns a `DeepSignalSet<T>` containing all objects of the given shape type.
-
-```typescript
-const dogs = useShape(DogShapeType);
+const jack = people.find((p) => p["@id"] === dog.owner);
 ```
 
-**DeepSignalSet methods:**
-- `add(obj)` — Add a new object
-- `delete(obj)` — Remove an object
-- `has(obj)` — Check if object exists
-- `size` — Number of objects
-- `getBy(graphIri, subjectIri)` — Find object by IRIs
-- `[Symbol.iterator]` — Iterate with `for...of` or spread `[...set]`
-- ... and all symbol iterator helper methods (like `.map`, `.find`, ...), if you are in an ES2025+ environment.
+Note that when you delete a nested object from a parent, _only the linkage_ to it is removed. The nested object itself (its quads) are not deleted.
 
-### Shared State
+---
 
-When `useShape()` is called with the same shape type and scope in multiple components, they share the exact same reactive data. Changes in one component instantly appear in all others.
+## About NextGraph
 
----
+> **NextGraph** brings about the convergence of P2P and Semantic Web technologies, towards a decentralized, secure and privacy-preserving cloud, based on CRDTs.
+>
+> This open source ecosystem provides solutions for end-users (a platform) and software developers (a framework), wishing to use or create **decentralized** apps featuring: **live collaboration** on rich-text documents, peer to peer communication with **end-to-end encryption**, offline-first, **local-first**, portable and interoperable data, total ownership of data and software, security and privacy.
+>
+> Centered on repositories containing **semantic data** (RDF), **rich text**, and structured data formats like **JSON**, synced between peers belonging to permissioned groups of users, it offers strong eventual consistency, thanks to the use of **CRDTs**. Documents can be linked together, signed, shared securely, queried using the **SPARQL** language and organized into sites and containers.
+>
+> More info: [https://nextgraph.org](https://nextgraph.org)
 
 ## License
 
@@ -337,7 +258,7 @@ Licensed under either of
 
 - Apache License, Version 2.0 ([LICENSE-APACHE2](LICENSE-APACHE2) or http://www.apache.org/licenses/LICENSE-2.0)
 - MIT license ([LICENSE-MIT](LICENSE-MIT) or http://opensource.org/licenses/MIT)
-  
+
 at your option.
 
 `SPDX-License-Identifier: Apache-2.0 OR MIT`

package/dist/connector/applyPatches.d.ts

@@ -1,9 +1,11 @@
+/** @ignore */
 export type Patch = {
     /** Property path (array indices, object keys, synthetic Set entry ids) from the root to the mutated location. */
     path: string;
     valType?: string & {};
     value?: unknown;
-} & (SetAddPatch | SetRemovePatch | ObjectAddPatch | RemovePatch | LiteralAddPatch);
+} & (SetAddPatch | SetRemovePatch | RemovePatch | LiteralAddPatch);
+/** @ignore */
 export interface SetAddPatch {
     /** Mutation kind applied at the resolved `path`. */
     op: "add";
@@ -15,6 +17,7 @@ export interface SetAddPatch {
      */
     value: number | string | boolean | (number | string | boolean)[];
 }
+/** @ignore */
 export interface SetRemovePatch {
     /** Mutation kind applied at the resolved `path`. */
     op: "remove";
@@ -24,83 +27,50 @@ export interface SetRemovePatch {
      *  - A single primitive
      *  - An array of primitives
      */
-    value: number | string | boolean | (number | string | boolean)[];
-}
-export interface ObjectAddPatch {
-    /** Mutation kind applied at the resolved `path`. */
-    op: "add";
-    valType: "object";
+    value: number | string | boolean | object | (number | string | boolean | object)[];
 }
+/** @ignore */
 export interface RemovePatch {
     /** Mutation kind applied at the resolved `path`. */
     op: "remove";
 }
+/** @ignore */
 export interface LiteralAddPatch {
     /** Mutation kind applied at the resolved `path`. */
     op: "add";
     /** The literal value to be added at the resolved `path` */
-    value: string | number | boolean;
+    value: string | number | boolean | object;
 }
 /**
+ * @ignore
+ *
  * Apply a diff to an object.
  *
  * The syntax is inspired by RFC 6902 but it is not compatible.
  *
  * It supports Sets for multi-valued properties:
  *   - Primitive values are added as Sets (Set<string | number | boolean>)
- *   - Multi-valued objects are stored in Sets, accessed by their @id property
- *   - Single objects are plain objects with an @id property
+ *   - Multi-valued objects are stored in Sets, accessed by their `@id` property
+ *   - Single objects are plain objects with an `@id` property
  *
  * Path traversal:
- *   - When traversing through a Set, the path segment is treated as an @id to find the object
+ *   - When traversing through a Set, the path segment is treated as an `@id` to find the object
  *   - When traversing through a plain object, the path segment is a property name
  *
- * @example operations
- *   ```jsonc
- *     // === SINGLE OBJECT ===
- *     // Creating a single object (has @id at same level)
- *     { "op": "add", "path": "/urn:example:person1/address", "valType": "object" }
- *     { "op": "add", "path": "/urn:example:person1/address/@id", "value": "urn:test:address1" }
- *     // Adding primitives to single object
- *     { "op": "add", "path": "/urn:example:person1/address/street", "value": "1st street" }
- *     { "op": "add", "path": "/urn:example:person1/address/country", "value": "Greece" }
- *     // Remove a primitive from object
- *     { "op": "remove", "path": "/urn:example:person1/address/street" }
- *     // Remove the entire object
- *     { "op": "remove", "path": "/urn:example:person1/address" }
- *
- *     // === MULTI-VALUED OBJECTS (Set) ===
- *     // Creating a multi-object container (NO @id at this level -> creates Set)
- *     { "op": "add", "path": "/urn:example:person1/children", "valType": "object" }
- *     // Adding an object to the Set (path includes object's @id)
- *     { "op": "add", "path": "/urn:example:person1/children/urn:example:child1", "valType": "object" }
- *     { "op": "add", "path": "/urn:example:person1/children/urn:example:child1/@id", "value": "urn:example:child1" }
- *     // Adding properties to object in Set
- *     { "op": "add", "path": "/urn:example:person1/children/urn:example:child1/name", "value": "Alice" }
- *     // Remove an object from Set
- *     { "op": "remove", "path": "/urn:example:person1/children/urn:example:child1" }
- *     // Remove all objects (the Set itself)
- *     { "op": "remove", "path": "/urn:example:person1/children" }
- *
- *     // === PRIMITIVE SETS ===
- *     // Add primitive types to Sets
- *     { "op": "add", "valType": "set", "path": "/urn:example:person1/tags", "value": [1,2,3] }
- *     // Remove primitive types from a Set
- *     { "op": "remove", "valType": "set", "path": "/urn:example:person1/tags", "value": [1,2] }
- * ```
- *
  * @param currentState The object before the patch
  * @param patches An array of patches to apply to the object.
  * @param ensurePathExists If true, create nested objects along the path if the path does not exist.
  *
- * @note When creating new objects, this function pre-scans upcoming patches to find @id and @graph
+ * Note: When creating new objects, this function pre-scans upcoming patches to find `@id` and `@graph`
  *       values that will be assigned to the object. This prevents the signal library's propGenerator
  *       from being triggered before these identity fields are set, which would cause it to generate
  *       random IDs unnecessarily.
  */
-export declare function applyPatches(currentState: Record<string, any>, patches: Patch[], ensurePathExists?: boolean): void;
+export declare function applyPatches(currentState: Record<string, any>, patches: Patch[], ormType: "set" | "discrete", ensurePathExists?: boolean): void;
 /**
- * See documentation for applyDiff
+ * @ignore
+ *
+ * See documentation for applyPatches
  */
-export declare function applyPatchesToDeepSignal(currentState: object, patch: Patch[]): void;
+export declare function applyPatchesToDeepSignal(currentState: object, patch: Patch[], ormType: "set" | "discrete"): void;
 //# sourceMappingURL=applyPatches.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"applyPatches.d.ts","sourceRoot":"","sources":["../../src/connector/applyPatches.ts"],"names":[],"mappings":"AAYA,MAAM,MAAM,KAAK,GAAG;IAChB,iHAAiH;IACjH,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,MAAM,GAAG,EAAE,CAAC;IACtB,KAAK,CAAC,EAAE,OAAO,CAAC;CACnB,GAAG,CACE,WAAW,GACX,cAAc,GACd,cAAc,GACd,WAAW,GACX,eAAe,CACpB,CAAC;AAEF,MAAM,WAAW,WAAW;IACxB,oDAAoD;IACpD,EAAE,EAAE,KAAK,CAAC;IACV,OAAO,EAAE,KAAK,CAAC;IACf;;;;OAIG;IACH,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,CAAC,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,EAAE,CAAC;CACpE;AAED,MAAM,WAAW,cAAc;IAC3B,oDAAoD;IACpD,EAAE,EAAE,QAAQ,CAAC;IACb,OAAO,EAAE,KAAK,CAAC;IACf;;;;OAIG;IACH,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,CAAC,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,EAAE,CAAC;CACpE;AAED,MAAM,WAAW,cAAc;IAC3B,oDAAoD;IACpD,EAAE,EAAE,KAAK,CAAC;IACV,OAAO,EAAE,QAAQ,CAAC;CACrB;AAED,MAAM,WAAW,WAAW;IACxB,oDAAoD;IACpD,EAAE,EAAE,QAAQ,CAAC;CAChB;AAED,MAAM,WAAW,eAAe;IAC5B,oDAAoD;IACpD,EAAE,EAAE,KAAK,CAAC;IACV,2DAA2D;IAC3D,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC;CACpC;AAyCD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwDG;AACH,wBAAgB,YAAY,CACxB,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EACjC,OAAO,EAAE,KAAK,EAAE,EAChB,gBAAgB,GAAE,OAAe,QAgOpC;AAED;;GAEG;AACH,wBAAgB,wBAAwB,CAAC,YAAY,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,EAAE,QAI5E"}
+{"version":3,"file":"applyPatches.d.ts","sourceRoot":"","sources":["../../src/connector/applyPatches.ts"],"names":[],"mappings":"AAYA,cAAc;AACd,MAAM,MAAM,KAAK,GAAG;IAChB,iHAAiH;IACjH,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,MAAM,GAAG,EAAE,CAAC;IACtB,KAAK,CAAC,EAAE,OAAO,CAAC;CACnB,GAAG,CAAC,WAAW,GAAG,cAAc,GAAG,WAAW,GAAG,eAAe,CAAC,CAAC;AAEnE,cAAc;AACd,MAAM,WAAW,WAAW;IACxB,oDAAoD;IACpD,EAAE,EAAE,KAAK,CAAC;IACV,OAAO,EAAE,KAAK,CAAC;IACf;;;;OAIG;IACH,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,CAAC,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,EAAE,CAAC;CACpE;AAED,cAAc;AACd,MAAM,WAAW,cAAc;IAC3B,oDAAoD;IACpD,EAAE,EAAE,QAAQ,CAAC;IACb,OAAO,EAAE,KAAK,CAAC;IACf;;;;OAIG;IACH,KAAK,EACC,MAAM,GACN,MAAM,GACN,OAAO,GACP,MAAM,GACN,CAAC,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,CAAC,EAAE,CAAC;CAChD;AAED,cAAc;AACd,MAAM,WAAW,WAAW;IACxB,oDAAoD;IACpD,EAAE,EAAE,QAAQ,CAAC;CAChB;AAED,cAAc;AACd,MAAM,WAAW,eAAe;IAC5B,oDAAoD;IACpD,EAAE,EAAE,KAAK,CAAC;IACV,2DAA2D;IAC3D,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,CAAC;CAC7C;AAyCD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,YAAY,CACxB,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EACjC,OAAO,EAAE,KAAK,EAAE,EAChB,OAAO,EAAE,KAAK,GAAG,UAAU,EAC3B,gBAAgB,GAAE,OAAe,QA6PpC;AAED;;;;GAIG;AACH,wBAAgB,wBAAwB,CACpC,YAAY,EAAE,MAAM,EACpB,KAAK,EAAE,KAAK,EAAE,EACd,OAAO,EAAE,KAAK,GAAG,UAAU,QAU9B"}