std-react-bindings 0.0.1

package/LICENSE

@@ -0,0 +1,19 @@
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,146 @@
+# std-react-bindings
+
+Data Bindings for React
+
+A binding is a wrapper type that can be used to read, write, and observe changes in a source of truth.
+
+This package provides an implementation of bindings that works well with React and React Native. It also provides a few convenient tools for working with these bindings.
+
+## Basic Example
+
+In the following example, we demonstrate creating, reading, and updating a binding as well as observing it for changes in two ways:
+
+- using `useBindingEffect`, which triggers a callback whenever the associated bindings change
+- using `BindingsConsumer`, which runs a render function whenever the associated bindings change
+
+```typescript
+import React from 'react';
+import { BindingsConsumer, useBinding, useBindingEffect } from 'std-react-bindings';
+
+export const MyComponent = () => {
+  // Creating a binding, initialized with 0
+  const myBinding = useBinding(() => 0, { id: 'myBinding' });
+
+  // Getting and logging the value of the binding
+  console.log('myBinding', myBinding.get()); // myBinding 0
+
+  // Setting the value of the binding
+  myBinding.set(1);
+
+  console.log('myBinding', myBinding.get()); // myBinding 1
+
+  // Registering a callback that will be triggered anytime the binding changes, while this component is mounted.
+  // By default, these calls are debounced.
+  useBindingEffect({ myBinding }, ({ myBinding }) => {
+    console.log('myBinding', myBinding);
+  });
+
+  const onIncClick = () => myBinding.set(myBinding.get() + 1);
+
+  // The rendered component includes a portion that will be automatically rerendered whenever the binding changes.
+  // By default, these rerenders are debounced.
+  return (
+    <div>
+      myBinding:&nbsp;
+      <BindingsConsumer bindings={{ myBinding }}>{({ myBinding }) => myBinding}</BindingsConsumer>
+      &nbsp;
+      <button onClick={onIncClick}>Increment</button>
+    </div>
+  );
+};
+```
+
+Things become a lot more interesting when you start passing bindings around, including them in React contexts, and dealing with asynchronous updates.
+
+Bindings provide some additional functionality by default, such as locking, and they're also extensible, as we'll see more later. But, be sure to check out the API docs for more complete details.
+
+For cases where you want to observe but not modify, you can use the `ReadonlyBinding` interface. This package also provides three specialized forms of readonly binding:
+
+- derived bindings - bindings derived from zero or more other bindings
+- const bindings - good for forcing non-binding wrapped data into a binding, for interfaces that expect such
+- flattened bindings - bindings derived from bindings that point to other bindings
+
+## Another Example
+
+In the following example, we make a component that is updated with a new random number every second. It displays the number as well as whether or not the number is even.
+
+```typescript
+import React, { useEffect } from 'react';
+import { Binding, BindingsConsumer, useBinding, useDerivedBinding } from 'std-react-bindings';
+
+const streamRandomNumbers = (binding: Binding<number>) => {
+  const next = () => {
+    binding.set(Math.floor(Math.random() * 100));
+    timeout = setTimeout(next, 1000);
+  };
+
+  let timeout = setTimeout(next, 1000);
+  next();
+
+  return () => {
+    clearTimeout(timeout);
+  };
+};
+
+export const MyComponent = () => {
+  // Creating a binding initialized with 0
+  const myBinding = useBinding(() => 0, { id: 'myBinding', detectChanges: true });
+  // Creating a derived binding based on the evenness of myBinding's value
+  // These values are propagated in a debounced way by default
+  const isEven = useDerivedBinding({ myBinding }, ({ myBinding }) => myBinding % 2 === 0, { id: 'isEven' });
+
+  // Connecting to a function that will stream in a new random number every second, as long as this component is mounted
+  useEffect(() => {
+    const stop = streamRandomNumbers(myBinding);
+
+    return stop;
+  });
+
+  // The rendered component has two dynamically rendered portions, which will automatically be rerendered whenever their associated bindings
+  // change.
+  return (
+    <div>
+      <BindingsConsumer bindings={{ myBinding }}>{({ myBinding }) => myBinding}</BindingsConsumer>
+      &nbsp;is even:&nbsp;
+      <BindingsConsumer bindings={{ isEven }}>{({ isEven }) => (isEven ? 'true' : 'false')}</BindingsConsumer>
+    </div>
+  );
+};
+```
+
+In the above example, we could have also chosen to set `limitType: 'none'` on the `isEven` derived binding, which would change the limiter from the default, which is `'debounce'`, so that propagation of changes from `myBinding` to `isEven` would happen immediately. However, it's generally better to only do that when it's critical that data be in sync because too many chained updates could lead to reduced frame rates and laggy user interactions.
+
+## Extensibility Example
+
+To demonstrate binding extensibility, let's revise the above example so that the `isEven` function is a property of `myBinding` directly, instead of being a derived binding.
+
+```typescript
+export const MyComponent = () => {
+  // Creating a binding initialized with 0 with an extra isEven field
+  const myBinding = useBinding(() => 0, {
+    id: 'myBinding',
+    detectChanges: true,
+    addFields: (b) => ({
+      isEven: () => b.get() % 2 === 0
+    })
+  });
+
+  // Connecting to a function that will stream in a new random number every second, as long as this component is mounted
+  useEffect(() => streamRandomNumbers(myBinding));
+
+  // The dynamic renderer use the binding directly instead of extracting the value and we're using the injected isEven function
+  return (
+    <div>
+      <BindingsConsumer bindings={myBinding}>
+        {() => (
+          <>
+            {myBinding.get()}
+            &nbsp;is even:&nbsp;
+            {myBinding.isEven() ? 'true' : 'false'}
+          </>
+        )}
+      </BindingsConsumer>
+    </div>
+  );
+};
+```

package/lib/bc/bc.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+import type { BindingDependencies } from '../binding/types/binding-dependencies';
+import type { BindingsConsumerRenderCallback } from '../components/BindingsConsumer';
+/** Returns a BindingsConsumer JSX Element.  This is useful as a shorthand especially when passing BindingsConsumers as props of other
+ * components */
+export declare const BC: <DependenciesT extends BindingDependencies>(bindings: DependenciesT, children: BindingsConsumerRenderCallback<DependenciesT>) => React.JSX.Element;
+//# sourceMappingURL=bc.d.ts.map

package/lib/bc/bc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bc.d.ts","sourceRoot":"","sources":["../../src/bc/bc.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAE1B,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,uCAAuC,CAAC;AACjF,OAAO,KAAK,EAAE,8BAA8B,EAAE,MAAM,gCAAgC,CAAC;AAGrF;gBACgB;AAChB,eAAO,MAAM,EAAE,oJAGyD,CAAC"}

package/lib/bc/exports.d.ts

@@ -0,0 +1,2 @@
+export * from './bc';
+//# sourceMappingURL=exports.d.ts.map

package/lib/bc/exports.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exports.d.ts","sourceRoot":"","sources":["../../src/bc/exports.ts"],"names":[],"mappings":"AAAA,cAAc,MAAM,CAAC"}

package/lib/binding/exports.d.ts

@@ -0,0 +1,4 @@
+export * from './make-binding';
+export * from './types/exports';
+export * from './use-binding';
+//# sourceMappingURL=exports.d.ts.map

package/lib/binding/exports.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exports.d.ts","sourceRoot":"","sources":["../../src/binding/exports.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC;AAC/B,cAAc,iBAAiB,CAAC;AAChC,cAAc,eAAe,CAAC"}

package/lib/binding/internal/DoubleLinkedList/index.d.ts

@@ -0,0 +1,25 @@
+export declare class DoubleLinkedList<ItemT> {
+    /** This is set to `undefined` on any list mutations and rebuilt when `toArray` is called if needed */
+    private allValues;
+    private firstNode;
+    private lastNode;
+    private length;
+    constructor(...items: ItemT[]);
+    readonly getLength: () => number;
+    readonly isEmpty: () => boolean;
+    readonly append: (item: ItemT) => Readonly<DoubleLinkedListNode<ItemT>>;
+    readonly prepend: (item: ItemT) => Readonly<DoubleLinkedListNode<ItemT>>;
+    readonly clear: () => void;
+    readonly getHead: () => Readonly<DoubleLinkedListNode<ItemT>> | undefined;
+    readonly getTail: () => Readonly<DoubleLinkedListNode<ItemT>> | undefined;
+    readonly toArray: () => Readonly<ItemT[]>;
+    readonly remove: (node: DoubleLinkedListNode<ItemT>) => boolean;
+}
+export declare class DoubleLinkedListNode<ItemT> {
+    list: DoubleLinkedList<ItemT> | undefined;
+    readonly value: ItemT;
+    previousNode?: DoubleLinkedListNode<ItemT> | undefined;
+    nextNode?: DoubleLinkedListNode<ItemT> | undefined;
+    constructor(list: DoubleLinkedList<ItemT> | undefined, value: ItemT, previousNode?: DoubleLinkedListNode<ItemT> | undefined, nextNode?: DoubleLinkedListNode<ItemT> | undefined);
+}
+//# sourceMappingURL=index.d.ts.map

package/lib/binding/internal/DoubleLinkedList/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/binding/internal/DoubleLinkedList/index.ts"],"names":[],"mappings":"AAAA,qBAAa,gBAAgB,CAAC,KAAK;IACjC,sGAAsG;IACtG,OAAO,CAAC,SAAS,CAAgC;IAEjD,OAAO,CAAC,SAAS,CAA0C;IAC3D,OAAO,CAAC,QAAQ,CAA0C;IAC1D,OAAO,CAAC,MAAM,CAAK;gBAEA,GAAG,KAAK,EAAE,KAAK,EAAE;IAMpC,SAAgB,SAAS,eAAqB;IAC9C,SAAgB,OAAO,gBAAsC;IAE7D,SAAgB,MAAM,SAAU,KAAK,KAAG,SAAS,qBAAqB,KAAK,CAAC,CAAC,CAgB3E;IAEF,SAAgB,OAAO,SAAU,KAAK,KAAG,SAAS,qBAAqB,KAAK,CAAC,CAAC,CAgB5E;IAEF,SAAgB,KAAK,aAInB;IAEF,SAAgB,OAAO,QAAO,SAAS,qBAAqB,KAAK,CAAC,CAAC,GAAG,SAAS,CAAmB;IAClG,SAAgB,OAAO,QAAO,SAAS,qBAAqB,KAAK,CAAC,CAAC,GAAG,SAAS,CAAkB;IAEjG,SAAgB,OAAO,QAAO,SAAS,KAAK,EAAE,CAAC,CAe7C;IAEF,SAAgB,MAAM,SAAU,qBAAqB,KAAK,CAAC,aAsCzD;CACH;AAED,qBAAa,oBAAoB,CAAC,KAAK;IAE5B,IAAI,EAAE,gBAAgB,CAAC,KAAK,CAAC,GAAG,SAAS;aAChC,KAAK,EAAE,KAAK;IACrB,YAAY,CAAC;IACb,QAAQ,CAAC;gBAHT,IAAI,EAAE,gBAAgB,CAAC,KAAK,CAAC,GAAG,SAAS,EAChC,KAAK,EAAE,KAAK,EACrB,YAAY,CAAC,yCAA6B,EAC1C,QAAQ,CAAC,yCAA6B;CAEhD"}

package/lib/binding/internal/binding-impl.d.ts

@@ -0,0 +1,60 @@
+import type { Binding } from '../types/binding';
+import type { BindingConstructorArgs } from '../types/binding-args';
+import type { BindingInitializer } from '../types/binding-initializer';
+import type { ChangeListener } from '../types/change-listener';
+import type { SetValueTransformer } from '../types/set-value-transformer';
+/** The standard implementation of a read-write binding */
+export declare class BindingImpl<GetType = any> implements Binding<GetType> {
+    readonly isBinding = true;
+    readonly id: string;
+    readonly uid: string;
+    readonly setValueTransformer: SetValueTransformer<GetType> | undefined;
+    /** The stored value of the binding */
+    private value_;
+    /** An ID updated every time the value is changed.  This value is unique to this runtime. */
+    private changeUid_;
+    /** Registered change listeners */
+    private onChangeListeners_?;
+    /**
+     * A flag indicating whether or not this binding was modified.  This is initially `false` when the binding is created and set to `true`
+     * when `set` is called (even if the underlying value doesn't actually change).
+     *
+     * This can also be set manually using `setIsModified`.
+     */
+    private isModified_;
+    /** This binding is considered to be locked if `> 0` */
+    private lockedCount_;
+    /**
+     * We keep track of the most-recent mutating call made while this binding is locked.  When it becomes unlocked, we apply the requested
+     * change.
+     */
+    private pending_;
+    /**
+     * In addition to tracking the most-recent mutating call made while this binding is locked, we also track if any of those mutating calls
+     * were resets.  If they were, when this binding becomes unlocked, we first reset and then apply the pending update.
+     */
+    private hasPendingReset_;
+    /** The value equality checker function */
+    private areEqual_?;
+    /** If `true`, `areEqual_` (or the default) is used to determine if the value has changed */
+    private detectChanges_;
+    /** The initializer function, which can be used to reset the binding */
+    private initializer_;
+    /**
+     * @param initializer - A function called to initialize this binding's value, which can also be called to reset its value.
+     * @param args - Additional arguments for configuring this binding.
+     */
+    constructor(initializer: BindingInitializer<GetType>, args: BindingConstructorArgs<GetType>);
+    readonly get: () => GetType;
+    readonly getChangeUid: () => string;
+    readonly reset: () => void;
+    readonly setRaw: (newValue: GetType) => void;
+    readonly set: (newValue: GetType) => void;
+    readonly isModified: () => boolean;
+    readonly setIsModified: (newIsModified: boolean) => void;
+    readonly isLocked: () => boolean;
+    readonly lock: () => () => void;
+    readonly addChangeListener: (listener: ChangeListener) => () => void;
+    readonly triggerChangeListeners: () => number;
+}
+//# sourceMappingURL=binding-impl.d.ts.map

package/lib/binding/internal/binding-impl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"binding-impl.d.ts","sourceRoot":"","sources":["../../../src/binding/internal/binding-impl.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAC;AAChD,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,uBAAuB,CAAC;AACpE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,8BAA8B,CAAC;AACvE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAC/D,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,gCAAgC,CAAC;AAW1E,0DAA0D;AAC1D,qBAAa,WAAW,CAAC,OAAO,GAAG,GAAG,CAAE,YAAW,OAAO,CAAC,OAAO,CAAC;IAGjE,SAAgB,SAAS,QAAQ;IACjC,SAAgB,EAAE,EAAE,MAAM,CAAC;IAC3B,SAAgB,GAAG,SAAa;IAEhC,SAAgB,mBAAmB,EAAE,mBAAmB,CAAC,OAAO,CAAC,GAAG,SAAS,CAAC;IAI9E,sCAAsC;IACtC,OAAO,CAAC,MAAM,CAAU;IAExB,4FAA4F;IAC5F,OAAO,CAAC,UAAU,CAAY;IAC9B,kCAAkC;IAClC,OAAO,CAAC,kBAAkB,CAAC,CAAmC;IAE9D;;;;;OAKG;IACH,OAAO,CAAC,WAAW,CAAS;IAE5B,uDAAuD;IACvD,OAAO,CAAC,YAAY,CAAK;IACzB;;;OAGG;IACH,OAAO,CAAC,QAAQ,CAAiD;IACjE;;;OAGG;IACH,OAAO,CAAC,gBAAgB,CAAS;IAEjC,0CAA0C;IAC1C,OAAO,CAAC,SAAS,CAAC,CAAsC;IACxD,4FAA4F;IAC5F,OAAO,CAAC,cAAc,CAAU;IAEhC,uEAAuE;IACvE,OAAO,CAAC,YAAY,CAA8B;IAElD;;;OAGG;gBACS,WAAW,EAAE,kBAAkB,CAAC,OAAO,CAAC,EAAE,IAAI,EAAE,sBAAsB,CAAC,OAAO,CAAC;IAgB3F,SAAgB,GAAG,gBAAqB;IAExC,SAAgB,YAAY,eAAyB;IAIrD,SAAgB,KAAK,aAanB;IAEF,SAAgB,MAAM,aAAc,OAAO,UA4BzC;IAEF,SAAgB,GAAG,aAAc,OAAO,UAWtC;IAIF,SAAgB,UAAU,gBAA0B;IAEpD,SAAgB,aAAa,kBAAmB,OAAO,UAErD;IAIF,SAAgB,QAAQ,gBAA+B;IAEvD,SAAgB,IAAI,mBAmDlB;IAIF,SAAgB,iBAAiB,aAAc,cAAc,gBAmB3D;IAEF,SAAgB,sBAAsB,eAWpC;CACH"}

package/lib/binding/internal/consts.d.ts

@@ -0,0 +1,3 @@
+/** The duration after which a warning will be logged if a lock hasn't been released */
+export declare const LOCK_DURATION_WARNING_INTERVAL_MSEC: number;
+//# sourceMappingURL=consts.d.ts.map

package/lib/binding/internal/consts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"consts.d.ts","sourceRoot":"","sources":["../../../src/binding/internal/consts.ts"],"names":[],"mappings":"AAAA,uFAAuF;AACvF,eAAO,MAAM,mCAAmC,QAAY,CAAC"}

package/lib/binding/make-binding.d.ts

@@ -0,0 +1,7 @@
+import type { EmptyObject } from '../types/empty';
+import type { Binding } from './types/binding';
+import type { MakeBindingArgs } from './types/binding-args';
+import type { BindingInitializer } from './types/binding-initializer';
+/** Makes a binding without using any React contexts. */
+export declare const makeBinding: <GetType = any, ExtraFieldsT extends object = EmptyObject>(initialValue: BindingInitializer<GetType>, args: MakeBindingArgs<GetType, ExtraFieldsT>) => Binding<GetType> & ExtraFieldsT;
+//# sourceMappingURL=make-binding.d.ts.map

package/lib/binding/make-binding.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"make-binding.d.ts","sourceRoot":"","sources":["../../src/binding/make-binding.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAElD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAC/C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAC5D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,6BAA6B,CAAC;AAEtE,wDAAwD;AACxD,eAAO,MAAM,WAAW,wLAgBvB,CAAC"}

package/lib/binding/types/binding-args.d.ts

@@ -0,0 +1,44 @@
+import type { DependencyList } from 'react';
+import type { EmptyObject } from '../../types/empty';
+import type { Binding } from './binding';
+import type { SetValueTransformer } from './set-value-transformer';
+/** Post-initializer arguments used to configure bindings */
+export interface BindingConstructorArgs<GetType = any> {
+    /** A technical, but human-readable ID, which isn't guaranteed to be unique */
+    id: string;
+    /**
+     * A transformer function called prior to storing the value when using the `set` method
+     *
+     * @param newValue - The proposed new value
+     * @param thisBinding - The binding being updated
+     *
+     * @returns The transformed value to set the binding to
+     */
+    setValueTransformer?: SetValueTransformer<GetType>;
+    /**
+     * If specified, overrides the function used to compare values
+     *
+     * @defaultValue `_.isEqual`, which can be globally overridden using `setAreEqual`
+     */
+    areEqual?: (a: GetType, b: GetType) => boolean;
+    /**
+     * - If `true` – `areEqual` is used to compare the old and new values when `set`/`setRaw` are called.  If the values are equal, the
+     * binding value won't be changed.  If they're unequal, the binding value will be changed and listeners will be notified.
+     * - If `false` – old and new values aren't compared when `set`/`setRaw` are called.  The binding will always be changed and listeners
+     * will always be notified.
+     *
+     * @defaultValue `false`
+     */
+    detectChanges?: boolean;
+}
+/** The post-initializer arguments that are passed to `makeBinding` */
+export interface MakeBindingArgs<GetType = any, ExtraFieldsT extends object = EmptyObject> extends BindingConstructorArgs<GetType> {
+    /** Use to support injecting additional fields into bindings */
+    addFields?: (thisBinding: Binding<GetType>) => ExtraFieldsT;
+}
+/** The post-initializer arguments that are passed to `useBinding` */
+export interface UseBindingArgs<GetType = any, ExtraFieldsT extends object = EmptyObject> extends MakeBindingArgs<GetType, ExtraFieldsT> {
+    /** Hook dependencies */
+    deps?: DependencyList;
+}
+//# sourceMappingURL=binding-args.d.ts.map

package/lib/binding/types/binding-args.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"binding-args.d.ts","sourceRoot":"","sources":["../../../src/binding/types/binding-args.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,OAAO,CAAC;AAE5C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACzC,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAEnE,4DAA4D;AAC5D,MAAM,WAAW,sBAAsB,CAAC,OAAO,GAAG,GAAG;IACnD,8EAA8E;IAC9E,EAAE,EAAE,MAAM,CAAC;IAEX;;;;;;;OAOG;IACH,mBAAmB,CAAC,EAAE,mBAAmB,CAAC,OAAO,CAAC,CAAC;IAEnD;;;;OAIG;IACH,QAAQ,CAAC,EAAE,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,KAAK,OAAO,CAAC;IAC/C;;;;;;;OAOG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB;AAED,sEAAsE;AACtE,MAAM,WAAW,eAAe,CAAC,OAAO,GAAG,GAAG,EAAE,YAAY,SAAS,MAAM,GAAG,WAAW,CAAE,SAAQ,sBAAsB,CAAC,OAAO,CAAC;IAChI,+DAA+D;IAC/D,SAAS,CAAC,EAAE,CAAC,WAAW,EAAE,OAAO,CAAC,OAAO,CAAC,KAAK,YAAY,CAAC;CAC7D;AAED,qEAAqE;AACrE,MAAM,WAAW,cAAc,CAAC,OAAO,GAAG,GAAG,EAAE,YAAY,SAAS,MAAM,GAAG,WAAW,CAAE,SAAQ,eAAe,CAAC,OAAO,EAAE,YAAY,CAAC;IACtI,wBAAwB;IACxB,IAAI,CAAC,EAAE,cAAc,CAAC;CACvB"}

package/lib/binding/types/binding-dependencies.d.ts

@@ -0,0 +1,5 @@
+import type { ReadonlyBinding } from './readonly-binding';
+export type BindingArrayDependencies = Array<ReadonlyBinding | undefined>;
+export type NamedBindingDependencies = Record<string, ReadonlyBinding | undefined>;
+export type BindingDependencies = ReadonlyBinding | BindingArrayDependencies | NamedBindingDependencies | undefined;
+//# sourceMappingURL=binding-dependencies.d.ts.map

package/lib/binding/types/binding-dependencies.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"binding-dependencies.d.ts","sourceRoot":"","sources":["../../../src/binding/types/binding-dependencies.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAE1D,MAAM,MAAM,wBAAwB,GAAG,KAAK,CAAC,eAAe,GAAG,SAAS,CAAC,CAAC;AAE1E,MAAM,MAAM,wBAAwB,GAAG,MAAM,CAAC,MAAM,EAAE,eAAe,GAAG,SAAS,CAAC,CAAC;AAEnF,MAAM,MAAM,mBAAmB,GAAG,eAAe,GAAG,wBAAwB,GAAG,wBAAwB,GAAG,SAAS,CAAC"}

package/lib/binding/types/binding-initializer.d.ts

@@ -0,0 +1,3 @@
+/** A function called to initialize a binding's value, which can also be called to reset its value. */
+export type BindingInitializer<GetType> = (isReset: boolean) => GetType;
+//# sourceMappingURL=binding-initializer.d.ts.map

package/lib/binding/types/binding-initializer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"binding-initializer.d.ts","sourceRoot":"","sources":["../../../src/binding/types/binding-initializer.ts"],"names":[],"mappings":"AAAA,sGAAsG;AACtG,MAAM,MAAM,kBAAkB,CAAC,OAAO,IAAI,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,CAAC"}

package/lib/binding/types/binding.d.ts

@@ -0,0 +1,22 @@
+import type { ReadonlyBinding } from './readonly-binding';
+import type { SetValueTransformer } from './set-value-transformer';
+/**
+ * A binding is a stored piece of data that notifies registered listeners when changed.
+ *
+ * @see `useBinding`
+ */
+export interface Binding<GetType = any> extends ReadonlyBinding<GetType> {
+    /** Resets the binding back to its initial value and marks the binding as non-modified. */
+    readonly reset: () => void;
+    /** Sets the value, using the result of `setValueTransformer` if set, and then marks the binding as modified. */
+    readonly set: (newValue: GetType) => void;
+    /** Sets the internal value without transforming or marking as changed.  Don't normally use this! */
+    readonly setRaw: (newValue: GetType) => void;
+    /** Sets the binding as having been modified or not */
+    readonly setIsModified: (isModified: boolean) => void;
+    /** If set, a function to transform the value before it's stored */
+    readonly setValueTransformer?: SetValueTransformer<GetType>;
+    /** Forcibly triggers the change listeners.  Don't normally use this! */
+    readonly triggerChangeListeners: () => void;
+}
+//# sourceMappingURL=binding.d.ts.map

package/lib/binding/types/binding.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"binding.d.ts","sourceRoot":"","sources":["../../../src/binding/types/binding.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAC1D,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAEnE;;;;GAIG;AACH,MAAM,WAAW,OAAO,CAAC,OAAO,GAAG,GAAG,CAAE,SAAQ,eAAe,CAAC,OAAO,CAAC;IACtE,0FAA0F;IAC1F,QAAQ,CAAC,KAAK,EAAE,MAAM,IAAI,CAAC;IAC3B,gHAAgH;IAChH,QAAQ,CAAC,GAAG,EAAE,CAAC,QAAQ,EAAE,OAAO,KAAK,IAAI,CAAC;IAC1C,oGAAoG;IACpG,QAAQ,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,OAAO,KAAK,IAAI,CAAC;IAE7C,sDAAsD;IACtD,QAAQ,CAAC,aAAa,EAAE,CAAC,UAAU,EAAE,OAAO,KAAK,IAAI,CAAC;IAEtD,mEAAmE;IACnE,QAAQ,CAAC,mBAAmB,CAAC,EAAE,mBAAmB,CAAC,OAAO,CAAC,CAAC;IAE5D,wEAAwE;IACxE,QAAQ,CAAC,sBAAsB,EAAE,MAAM,IAAI,CAAC;CAC7C"}

package/lib/binding/types/change-listener.d.ts

@@ -0,0 +1,5 @@
+/** Called when a change is made */
+export type ChangeListener = () => void;
+/** Call to remove a change listener */
+export type ChangeListenerRemover = () => void;
+//# sourceMappingURL=change-listener.d.ts.map

package/lib/binding/types/change-listener.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"change-listener.d.ts","sourceRoot":"","sources":["../../../src/binding/types/change-listener.ts"],"names":[],"mappings":"AAAA,mCAAmC;AACnC,MAAM,MAAM,cAAc,GAAG,MAAM,IAAI,CAAC;AAExC,uCAAuC;AACvC,MAAM,MAAM,qBAAqB,GAAG,MAAM,IAAI,CAAC"}

package/lib/binding/types/exports.d.ts

@@ -0,0 +1,12 @@
+export * from './binding';
+export * from './binding-args';
+export * from './binding-dependencies';
+export * from './binding-initializer';
+export * from './change-listener';
+export * from './infer-binding-value-types';
+export * from './infer-bindings-array-value-types';
+export * from './infer-named-binding-value-types';
+export * from './inference';
+export * from './readonly-binding';
+export * from './set-value-transformer';
+//# sourceMappingURL=exports.d.ts.map

package/lib/binding/types/exports.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exports.d.ts","sourceRoot":"","sources":["../../../src/binding/types/exports.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAC;AAC1B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,wBAAwB,CAAC;AACvC,cAAc,uBAAuB,CAAC;AACtC,cAAc,mBAAmB,CAAC;AAClC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,oCAAoC,CAAC;AACnD,cAAc,mCAAmC,CAAC;AAClD,cAAc,aAAa,CAAC;AAC5B,cAAc,oBAAoB,CAAC;AACnC,cAAc,yBAAyB,CAAC"}

package/lib/binding/types/infer-binding-value-types.d.ts

@@ -0,0 +1,8 @@
+import type { BindingArrayDependencies, BindingDependencies, NamedBindingDependencies } from './binding-dependencies';
+import type { InferBindingsArrayValueTypes } from './infer-bindings-array-value-types';
+import type { InferNamedBindingsValueTypes } from './infer-named-binding-value-types';
+import type { InferBindingGetType } from './inference';
+import type { ReadonlyBinding } from './readonly-binding';
+/** Infers the values of either a single binding, bindings in an array or tuple, or a record with binding values */
+export type InferBindingValueTypes<DependenciesT extends BindingDependencies> = DependenciesT extends ReadonlyBinding ? InferBindingGetType<DependenciesT> : DependenciesT extends NamedBindingDependencies ? InferNamedBindingsValueTypes<DependenciesT> : DependenciesT extends BindingArrayDependencies ? InferBindingsArrayValueTypes<DependenciesT> : Record<string, never>;
+//# sourceMappingURL=infer-binding-value-types.d.ts.map

package/lib/binding/types/infer-binding-value-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"infer-binding-value-types.d.ts","sourceRoot":"","sources":["../../../src/binding/types/infer-binding-value-types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,wBAAwB,EAAE,mBAAmB,EAAE,wBAAwB,EAAE,MAAM,wBAAwB,CAAC;AACtH,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,oCAAoC,CAAC;AACvF,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,mCAAmC,CAAC;AACtF,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AACvD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAE1D,mHAAmH;AACnH,MAAM,MAAM,sBAAsB,CAAC,aAAa,SAAS,mBAAmB,IAAI,aAAa,SAAS,eAAe,GACjH,mBAAmB,CAAC,aAAa,CAAC,GAClC,aAAa,SAAS,wBAAwB,GAC9C,4BAA4B,CAAC,aAAa,CAAC,GAC3C,aAAa,SAAS,wBAAwB,GAC9C,4BAA4B,CAAC,aAAa,CAAC,GAC3C,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC"}

package/lib/binding/types/infer-bindings-array-value-types.d.ts

@@ -0,0 +1,8 @@
+import type { BindingArrayDependencies } from './binding-dependencies';
+import type { InferBindingGetType } from './inference';
+import type { ReadonlyBinding } from './readonly-binding';
+/** Infers the value types from bindings arrays */
+export type InferBindingsArrayValueTypes<BindingsArrayT extends BindingArrayDependencies> = {
+    [KeyT in keyof BindingsArrayT]: BindingsArrayT[KeyT] extends ReadonlyBinding ? InferBindingGetType<BindingsArrayT[KeyT]> : BindingsArrayT[KeyT] extends ReadonlyBinding | undefined ? InferBindingGetType<BindingsArrayT[KeyT]> | undefined : BindingsArrayT[KeyT];
+};
+//# sourceMappingURL=infer-bindings-array-value-types.d.ts.map

package/lib/binding/types/infer-bindings-array-value-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"infer-bindings-array-value-types.d.ts","sourceRoot":"","sources":["../../../src/binding/types/infer-bindings-array-value-types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,wBAAwB,CAAC;AACvE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AACvD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAE1D,kDAAkD;AAClD,MAAM,MAAM,4BAA4B,CAAC,cAAc,SAAS,wBAAwB,IAAI;KACzF,IAAI,IAAI,MAAM,cAAc,GAAG,cAAc,CAAC,IAAI,CAAC,SAAS,eAAe,GACxE,mBAAmB,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC,GACzC,cAAc,CAAC,IAAI,CAAC,SAAS,eAAe,GAAG,SAAS,GACxD,mBAAmB,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC,GAAG,SAAS,GACrD,cAAc,CAAC,IAAI,CAAC;CACzB,CAAC"}

package/lib/binding/types/infer-named-binding-value-types.d.ts

@@ -0,0 +1,8 @@
+import type { NamedBindingDependencies } from './binding-dependencies';
+import type { InferBindingGetType } from './inference';
+import type { ReadonlyBinding } from './readonly-binding';
+/** Infers the value types from named bindings */
+export type InferNamedBindingsValueTypes<NamedBindingsT extends NamedBindingDependencies> = {
+    [KeyT in keyof NamedBindingsT]: NamedBindingsT[KeyT] extends ReadonlyBinding ? InferBindingGetType<NamedBindingsT[KeyT]> : NamedBindingsT[KeyT] extends ReadonlyBinding | undefined ? InferBindingGetType<NamedBindingsT[KeyT]> | undefined : NamedBindingsT[KeyT];
+};
+//# sourceMappingURL=infer-named-binding-value-types.d.ts.map

package/lib/binding/types/infer-named-binding-value-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"infer-named-binding-value-types.d.ts","sourceRoot":"","sources":["../../../src/binding/types/infer-named-binding-value-types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,wBAAwB,CAAC;AACvE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AACvD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAE1D,iDAAiD;AACjD,MAAM,MAAM,4BAA4B,CAAC,cAAc,SAAS,wBAAwB,IAAI;KACzF,IAAI,IAAI,MAAM,cAAc,GAAG,cAAc,CAAC,IAAI,CAAC,SAAS,eAAe,GACxE,mBAAmB,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC,GACzC,cAAc,CAAC,IAAI,CAAC,SAAS,eAAe,GAAG,SAAS,GACxD,mBAAmB,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC,GAAG,SAAS,GACrD,cAAc,CAAC,IAAI,CAAC;CACzB,CAAC"}

package/lib/binding/types/inference.d.ts

@@ -0,0 +1,4 @@
+import type { ReadonlyBinding } from './readonly-binding';
+/** Infers the stored value type from a binding type */
+export type InferBindingGetType<BindingT> = BindingT extends ReadonlyBinding<infer GetType> ? GetType : never;
+//# sourceMappingURL=inference.d.ts.map

package/lib/binding/types/inference.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inference.d.ts","sourceRoot":"","sources":["../../../src/binding/types/inference.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAE1D,uDAAuD;AACvD,MAAM,MAAM,mBAAmB,CAAC,QAAQ,IAAI,QAAQ,SAAS,eAAe,CAAC,MAAM,OAAO,CAAC,GAAG,OAAO,GAAG,KAAK,CAAC"}

package/lib/binding/types/readonly-binding.d.ts

@@ -0,0 +1,35 @@
+import type { ChangeListener, ChangeListenerRemover } from './change-listener';
+/** The readonly interface for bindings */
+export interface ReadonlyBinding<GetType = any> {
+    /** A marker indicating that this is a binding type */
+    readonly isBinding: true;
+    /** A technical, but human-readable ID, which isn't guaranteed to be unique */
+    readonly id: string;
+    /** An ID that's unique to this runtime */
+    readonly uid: string;
+    /**
+     * Adds a listener that will be called when this binding changes.
+     *
+     * @see `useBindingEffect` and `BindingsConsumer`
+     *
+     * @returns a function that may be used to remove the added listener.
+     */
+    readonly addChangeListener: (listener: ChangeListener) => ChangeListenerRemover;
+    /** @returns the value */
+    readonly get: () => GetType;
+    /** Every time the value is changed, the change uid is updated */
+    readonly getChangeUid: () => string;
+    /** @returns `true` if this binding has been marked as being modified */
+    readonly isModified: () => boolean;
+    /** @returns `true` if the binding is locked */
+    readonly isLocked: () => boolean;
+    /**
+     * Increments the lock count and returns a method to decrement it.  A binding is locked if its lock
+     * count is `> 0`.  When a binding is locked, mutating calls (`reset`/`set`/`setRaw`) won't have an immediate effect.  However, if a
+     * mutating call is made on a locked binding, the change will be applied once the binding becomes unlocked.
+     *
+     * @returns a function for decrementing this binding's lock count.
+     */
+    readonly lock: () => () => void;
+}
+//# sourceMappingURL=readonly-binding.d.ts.map

package/lib/binding/types/readonly-binding.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"readonly-binding.d.ts","sourceRoot":"","sources":["../../../src/binding/types/readonly-binding.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,qBAAqB,EAAE,MAAM,mBAAmB,CAAC;AAE/E,0CAA0C;AAC1C,MAAM,WAAW,eAAe,CAAC,OAAO,GAAG,GAAG;IAC5C,sDAAsD;IACtD,QAAQ,CAAC,SAAS,EAAE,IAAI,CAAC;IAEzB,8EAA8E;IAC9E,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,0CAA0C;IAC1C,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IAErB;;;;;;OAMG;IACH,QAAQ,CAAC,iBAAiB,EAAE,CAAC,QAAQ,EAAE,cAAc,KAAK,qBAAqB,CAAC;IAEhF,yBAAyB;IACzB,QAAQ,CAAC,GAAG,EAAE,MAAM,OAAO,CAAC;IAC5B,iEAAiE;IACjE,QAAQ,CAAC,YAAY,EAAE,MAAM,MAAM,CAAC;IACpC,wEAAwE;IACxE,QAAQ,CAAC,UAAU,EAAE,MAAM,OAAO,CAAC;IAEnC,+CAA+C;IAC/C,QAAQ,CAAC,QAAQ,EAAE,MAAM,OAAO,CAAC;IACjC;;;;;;OAMG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,MAAM,IAAI,CAAC;CACjC"}

package/lib/binding/types/set-value-transformer.d.ts

@@ -0,0 +1,11 @@
+import type { ReadonlyBinding } from './readonly-binding';
+/**
+ * A transformer function called prior to storing the value when using the `set` method
+ *
+ * @param newValue - The proposed new value
+ * @param thisBinding - The binding being updated
+ *
+ * @returns The transformed value to set the binding to
+ */
+export type SetValueTransformer<GetType> = (newValue: GetType, thisBinding: ReadonlyBinding<GetType>) => GetType;
+//# sourceMappingURL=set-value-transformer.d.ts.map

package/lib/binding/types/set-value-transformer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"set-value-transformer.d.ts","sourceRoot":"","sources":["../../../src/binding/types/set-value-transformer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAE1D;;;;;;;GAOG;AACH,MAAM,MAAM,mBAAmB,CAAC,OAAO,IAAI,CAAC,QAAQ,EAAE,OAAO,EAAE,WAAW,EAAE,eAAe,CAAC,OAAO,CAAC,KAAK,OAAO,CAAC"}

package/lib/binding/use-binding.d.ts

@@ -0,0 +1,7 @@
+import type { EmptyObject } from '../types/empty';
+import type { Binding } from './types/binding';
+import type { UseBindingArgs } from './types/binding-args';
+import type { BindingInitializer } from './types/binding-initializer';
+/** Makes a binding memo'd using the specified dependencies */
+export declare const useBinding: <GetType = any, ExtraFieldsT extends object = EmptyObject>(initialValue: BindingInitializer<GetType>, args: UseBindingArgs<GetType, ExtraFieldsT>) => Binding<GetType> & ExtraFieldsT;
+//# sourceMappingURL=use-binding.d.ts.map

package/lib/binding/use-binding.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-binding.d.ts","sourceRoot":"","sources":["../../src/binding/use-binding.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAElD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAC/C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAC3D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,6BAA6B,CAAC;AAItE,8DAA8D;AAC9D,eAAO,MAAM,UAAU,uLAIyG,CAAC"}

package/lib/binding-utils/exports.d.ts

@@ -0,0 +1,4 @@
+export * from './lock-utils';
+export * from './modified-utils';
+export * from './type-utils';
+//# sourceMappingURL=exports.d.ts.map

package/lib/binding-utils/exports.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exports.d.ts","sourceRoot":"","sources":["../../src/binding-utils/exports.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC;AAC7B,cAAc,kBAAkB,CAAC;AACjC,cAAc,cAAc,CAAC"}

package/lib/binding-utils/internal/make-value-then-do.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Runs a function to make a value and then runs a subsequent function.  The subsequent function is run even if an exception is thrown while
+ * making the value.  This efficiently handles value generation functions that return promises and that don't.
+ */
+export declare const makeValueThenDo: <T>(makeValue: () => T | Promise<T>, thenDo: (value?: T | undefined) => void) => T | Promise<T>;
+//# sourceMappingURL=make-value-then-do.d.ts.map

package/lib/binding-utils/internal/make-value-then-do.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"make-value-then-do.d.ts","sourceRoot":"","sources":["../../../src/binding-utils/internal/make-value-then-do.ts"],"names":[],"mappings":"AAEA;;;GAGG;AACH,eAAO,MAAM,eAAe,0EAA+D,IAAI,mBA8B9F,CAAC"}

package/lib/binding-utils/lock-utils.d.ts

@@ -0,0 +1,27 @@
+import type { ReadonlyBinding } from '../binding/types/readonly-binding';
+/**
+ * Checks if any of the specified bindings have been locked.
+ *
+ * @param bindings - The bindings to check
+ *
+ * @returns `true` if any of the specified bindings are locked, `false` otherwise.
+ */
+export declare const areAnyBindingsLocked: (bindings: Array<ReadonlyBinding | undefined>) => boolean;
+/**
+ * Locks all the specified bindings and returns a function for unlocking them in reverse order.
+ *
+ * @param bindings - The bindings to be locked
+ *
+ * @returns a function to unlock all of the specified bindings, in reverse order
+ */
+export declare const lockAllBindings: (bindings: Array<ReadonlyBinding | undefined>) => () => void;
+/**
+ * Locks the specified bindings until the functions result is resolved or rejected
+ *
+ * @param bindings - The bindings to be locked
+ * @param func - The function to run while the bindings are locked
+ *
+ * @returns The result of the specified function
+ */
+export declare const lockBindingsAndDo: <T>(bindings: Array<ReadonlyBinding | undefined>, func: () => T | Promise<T>) => T | Promise<T>;
+//# sourceMappingURL=lock-utils.d.ts.map

package/lib/binding-utils/lock-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lock-utils.d.ts","sourceRoot":"","sources":["../../src/binding-utils/lock-utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mCAAmC,CAAC;AAGzE;;;;;;GAMG;AACH,eAAO,MAAM,oBAAoB,aAAc,MAAM,eAAe,GAAG,SAAS,CAAC,YAQhF,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,eAAe,aAAc,MAAM,eAAe,GAAG,SAAS,CAAC,eAQ3E,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,iBAAiB,gBAAiB,MAAM,eAAe,GAAG,SAAS,CAAC,+CAIhF,CAAC"}