@tomorrowevening/theatre-dataverse 1.0.0 → 1.0.1

package/dist/integration.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=integration.test.d.ts.map

package/dist/integration.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"integration.test.d.ts","sourceRoot":"","sources":["../src/integration.test.ts"],"names":[],"mappings":""}

package/dist/pointer.d.ts

@@ -1,107 +1,107 @@
-import type { $IntentionalAny } from './types';
-type PathToProp = Array<string | number>;
-export type PointerMeta = {
-    root: {};
-    path: (string | number)[];
-};
-export type UnindexableTypesForPointer = number | string | boolean | null | void | undefined | Function;
-export type UnindexablePointer = {
-    [K in $IntentionalAny]: Pointer<undefined>;
-};
-/**
- * A wrapper type for the type a `Pointer` points to.
- */
-export type PointerType<O> = {
-    /**
-     * Only accessible via the type system.
-     * This is a helper for getting the underlying pointer type
-     * via the type space.
-     */
-    $$__pointer_type: O;
-};
-/**
- * The type of {@link Atom} pointers. See {@link pointer|pointer()} for an
- * explanation of pointers.
- *
- * @see Atom
- *
- * @remarks
- * The Pointer type is quite tricky because it doesn't play well with `any` and other inexact types.
- * Here is an example that one would expect to work, but currently doesn't:
- * ```ts
- * declare function expectAnyPointer(pointer: Pointer<any>): void
- *
- * expectAnyPointer(null as Pointer<{}>) // this shows as a type error because Pointer<{}> is not assignable to Pointer<any>, even though it should
- * ```
- *
- * The current solution is to just avoid using `any` with pointer-related code (or type-test it well).
- * But if you enjoy solving typescript puzzles, consider fixing this :)
- * Potentially, [TypeScript variance annotations in 4.7+](https://devblogs.microsoft.com/typescript/announcing-typescript-4-7-beta/#optional-variance-annotations-for-type-parameters)
- * might be able to help us.
- */
-export type Pointer<O> = PointerType<O> & PointerInner<Exclude<O, undefined>, undefined extends O ? undefined : never>;
-type PointerInner<O, Optional> = O extends UnindexableTypesForPointer ? UnindexablePointer : unknown extends O ? UnindexablePointer : O extends (infer T)[] ? Pointer<T>[] : O extends {} ? {
-    [K in keyof O]-?: Pointer<O[K] | Optional>;
-} : UnindexablePointer;
-/**
- * Returns the metadata associated with the pointer. Usually the root object and
- * the path.
- *
- * @param p - The pointer.
- */
-export declare const getPointerMeta: <_>(p: PointerType<_>) => PointerMeta;
-/**
- * Returns the root object and the path of the pointer.
- *
- * @example
- * ```ts
- * const {root, path} = getPointerParts(pointer)
- * ```
- *
- * @param p - The pointer.
- *
- * @returns An object with two properties: `root`-the root object or the pointer, and `path`-the path of the pointer. `path` is an array of the property-chain.
- */
-export declare const getPointerParts: <_>(p: Pointer<_>) => {
-    root: {};
-    path: PathToProp;
-};
-/**
- * Creates a pointer to a (nested) property of an {@link Atom}.
- *
- * @remarks
- * Pointers are used to make prisms of properties or nested properties of
- * {@link Atom|Atoms}.
- *
- * Pointers also allow easy construction of new pointers pointing to nested members
- * of the root object, by simply using property chaining. E.g. `somePointer.a.b` will
- * create a new pointer that has `'a'` and `'b'` added to the path of `somePointer`.
- *
- * @example
- * ```ts
- * // Here, sum is a prism that updates whenever the a or b prop of someAtom does.
- * const sum = prism(() => {
- *   return val(pointer({root: someAtom, path: ['a']})) + val(pointer({root: someAtom, path: ['b']}));
- * });
- *
- * // Note, atoms have a convenience Atom.pointer property that points to the root,
- * // which you would normally use in this situation.
- * const sum = prism(() => {
- *   return val(someAtom.pointer.a) + val(someAtom.pointer.b);
- * });
- * ```
- *
- * @param args - The pointer parameters.
- *
- * @typeParam O - The type of the value being pointed to.
- */
-declare function pointer<O>(args: {
-    root: {};
-    path?: Array<string | number>;
-}): Pointer<O>;
-export default pointer;
-/**
- * Returns whether `p` is a pointer.
- */
-export declare const isPointer: (p: $IntentionalAny) => p is Pointer<unknown>;
-//# sourceMappingURL=pointer.d.ts.map
+import type { $IntentionalAny } from './types';
+type PathToProp = Array<string | number>;
+export type PointerMeta = {
+    root: {};
+    path: (string | number)[];
+};
+export type UnindexableTypesForPointer = number | string | boolean | null | void | undefined | Function;
+export type UnindexablePointer = {
+    [K in $IntentionalAny]: Pointer<undefined>;
+};
+/**
+ * A wrapper type for the type a `Pointer` points to.
+ */
+export type PointerType<O> = {
+    /**
+     * Only accessible via the type system.
+     * This is a helper for getting the underlying pointer type
+     * via the type space.
+     */
+    $$__pointer_type: O;
+};
+/**
+ * The type of {@link Atom} pointers. See {@link pointer|pointer()} for an
+ * explanation of pointers.
+ *
+ * @see Atom
+ *
+ * @remarks
+ * The Pointer type is quite tricky because it doesn't play well with `any` and other inexact types.
+ * Here is an example that one would expect to work, but currently doesn't:
+ * ```ts
+ * declare function expectAnyPointer(pointer: Pointer<any>): void
+ *
+ * expectAnyPointer(null as Pointer<{}>) // this shows as a type error because Pointer<{}> is not assignable to Pointer<any>, even though it should
+ * ```
+ *
+ * The current solution is to just avoid using `any` with pointer-related code (or type-test it well).
+ * But if you enjoy solving typescript puzzles, consider fixing this :)
+ * Potentially, [TypeScript variance annotations in 4.7+](https://devblogs.microsoft.com/typescript/announcing-typescript-4-7-beta/#optional-variance-annotations-for-type-parameters)
+ * might be able to help us.
+ */
+export type Pointer<O> = PointerType<O> & PointerInner<Exclude<O, undefined>, undefined extends O ? undefined : never>;
+type PointerInner<O, Optional> = O extends UnindexableTypesForPointer ? UnindexablePointer : unknown extends O ? UnindexablePointer : O extends (infer T)[] ? Pointer<T>[] : O extends {} ? {
+    [K in keyof O]-?: Pointer<O[K] | Optional>;
+} : UnindexablePointer;
+/**
+ * Returns the metadata associated with the pointer. Usually the root object and
+ * the path.
+ *
+ * @param p - The pointer.
+ */
+export declare const getPointerMeta: <_>(p: PointerType<_>) => PointerMeta;
+/**
+ * Returns the root object and the path of the pointer.
+ *
+ * @example
+ * ```ts
+ * const {root, path} = getPointerParts(pointer)
+ * ```
+ *
+ * @param p - The pointer.
+ *
+ * @returns An object with two properties: `root`-the root object or the pointer, and `path`-the path of the pointer. `path` is an array of the property-chain.
+ */
+export declare const getPointerParts: <_>(p: Pointer<_>) => {
+    root: {};
+    path: PathToProp;
+};
+/**
+ * Creates a pointer to a (nested) property of an {@link Atom}.
+ *
+ * @remarks
+ * Pointers are used to make prisms of properties or nested properties of
+ * {@link Atom|Atoms}.
+ *
+ * Pointers also allow easy construction of new pointers pointing to nested members
+ * of the root object, by simply using property chaining. E.g. `somePointer.a.b` will
+ * create a new pointer that has `'a'` and `'b'` added to the path of `somePointer`.
+ *
+ * @example
+ * ```ts
+ * // Here, sum is a prism that updates whenever the a or b prop of someAtom does.
+ * const sum = prism(() => {
+ *   return val(pointer({root: someAtom, path: ['a']})) + val(pointer({root: someAtom, path: ['b']}));
+ * });
+ *
+ * // Note, atoms have a convenience Atom.pointer property that points to the root,
+ * // which you would normally use in this situation.
+ * const sum = prism(() => {
+ *   return val(someAtom.pointer.a) + val(someAtom.pointer.b);
+ * });
+ * ```
+ *
+ * @param args - The pointer parameters.
+ *
+ * @typeParam O - The type of the value being pointed to.
+ */
+declare function pointer<O>(args: {
+    root: {};
+    path?: Array<string | number>;
+}): Pointer<O>;
+export default pointer;
+/**
+ * Returns whether `p` is a pointer.
+ */
+export declare const isPointer: (p: $IntentionalAny) => p is Pointer<unknown>;
+//# sourceMappingURL=pointer.d.ts.map

package/dist/pointer.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=pointer.test.d.ts.map

package/dist/pointer.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pointer.test.d.ts","sourceRoot":"","sources":["../src/pointer.test.ts"],"names":[],"mappings":""}

package/dist/pointer.typeTest.d.ts

@@ -1,2 +1,2 @@
-export {};
-//# sourceMappingURL=pointer.typeTest.d.ts.map
+export {};
+//# sourceMappingURL=pointer.typeTest.d.ts.map

package/dist/pointerToPrism.d.ts

@@ -1,20 +1,20 @@
-import type { Prism } from './prism/Interface';
-import type { Pointer, PointerType } from './pointer';
-/**
- * Interface for objects that can provide a prism at a certain path.
- */
-export interface PointerToPrismProvider {
-    /**
-     * Returns a prism of the value at the provided pointer.
-     */
-    pointerToPrism<P>(pointer: Pointer<P>): Prism<P>;
-}
-export declare function isPointerToPrismProvider(val: unknown): val is PointerToPrismProvider;
-/**
- * Returns a prism of the value at the provided pointer. Prisms are
- * cached per pointer.
- *
- * @param pointer - The pointer to return the prism at.
- */
-export declare const pointerToPrism: <P extends PointerType<any>>(pointer: P) => Prism<P extends PointerType<infer T> ? T : void>;
-//# sourceMappingURL=pointerToPrism.d.ts.map
+import type { Prism } from './prism/Interface';
+import type { Pointer, PointerType } from './pointer';
+/**
+ * Interface for objects that can provide a prism at a certain path.
+ */
+export interface PointerToPrismProvider {
+    /**
+     * Returns a prism of the value at the provided pointer.
+     */
+    pointerToPrism<P>(pointer: Pointer<P>): Prism<P>;
+}
+export declare function isPointerToPrismProvider(val: unknown): val is PointerToPrismProvider;
+/**
+ * Returns a prism of the value at the provided pointer. Prisms are
+ * cached per pointer.
+ *
+ * @param pointer - The pointer to return the prism at.
+ */
+export declare const pointerToPrism: <P extends PointerType<any>>(pointer: P) => Prism<P extends PointerType<infer T> ? T : void>;
+//# sourceMappingURL=pointerToPrism.d.ts.map

package/dist/prism/Interface.d.ts

@@ -1,33 +1,33 @@
-import type Ticker from '../Ticker';
-import type { VoidFn } from '../types';
-/**
- * Common interface for prisms.
- */
-export interface Prism<V> {
-    /**
-     * Whether the object is a prism.
-     */
-    isPrism: true;
-    /**
-     * Whether the prism is hot.
-     */
-    isHot: boolean;
-    /**
-     * Calls `listener` with a fresh value every time the prism _has_ a new value, throttled by Ticker.
-     */
-    onChange(ticker: Ticker, listener: (v: V) => void, immediate?: boolean): VoidFn;
-    onStale(cb: () => void): VoidFn;
-    /**
-     * Keep the prism hot, even if there are no tappers (subscribers).
-     */
-    keepHot(): VoidFn;
-    /**
-     * Gets the current value of the prism. If the value is stale, it causes the prism to freshen.
-     */
-    getValue(): V;
-}
-/**
- * Returns whether `d` is a prism.
- */
-export declare function isPrism(d: any): d is Prism<unknown>;
-//# sourceMappingURL=Interface.d.ts.map
+import type Ticker from '../Ticker';
+import type { VoidFn } from '../types';
+/**
+ * Common interface for prisms.
+ */
+export interface Prism<V> {
+    /**
+     * Whether the object is a prism.
+     */
+    isPrism: true;
+    /**
+     * Whether the prism is hot.
+     */
+    isHot: boolean;
+    /**
+     * Calls `listener` with a fresh value every time the prism _has_ a new value, throttled by Ticker.
+     */
+    onChange(ticker: Ticker, listener: (v: V) => void, immediate?: boolean): VoidFn;
+    onStale(cb: () => void): VoidFn;
+    /**
+     * Keep the prism hot, even if there are no tappers (subscribers).
+     */
+    keepHot(): VoidFn;
+    /**
+     * Gets the current value of the prism. If the value is stale, it causes the prism to freshen.
+     */
+    getValue(): V;
+}
+/**
+ * Returns whether `d` is a prism.
+ */
+export declare function isPrism(d: any): d is Prism<unknown>;
+//# sourceMappingURL=Interface.d.ts.map

package/dist/prism/asyncIterateOver.d.ts

@@ -1 +1 @@
-//# sourceMappingURL=asyncIterateOver.d.ts.map
+//# sourceMappingURL=asyncIterateOver.d.ts.map

package/dist/prism/discoveryMechanism.d.ts

@@ -1,4 +1,4 @@
-import type { $IntentionalAny } from '../types';
-import type { Prism } from './Interface';
-export declare const startIgnoringDependencies: () => void, stopIgnoringDependencies: () => void, reportResolutionEnd: (_d: Prism<$IntentionalAny>) => void, reportResolutionStart: (d: Prism<$IntentionalAny>) => void, pushCollector: (collector: (d: Prism<$IntentionalAny>) => void) => void, popCollector: (collector: (d: Prism<$IntentionalAny>) => void) => void;
-//# sourceMappingURL=discoveryMechanism.d.ts.map
+import type { $IntentionalAny } from '../types';
+import type { Prism } from './Interface';
+export declare const startIgnoringDependencies: () => void, stopIgnoringDependencies: () => void, reportResolutionEnd: (_d: Prism<$IntentionalAny>) => void, reportResolutionStart: (d: Prism<$IntentionalAny>) => void, pushCollector: (collector: (d: Prism<$IntentionalAny>) => void) => void, popCollector: (collector: (d: Prism<$IntentionalAny>) => void) => void;
+//# sourceMappingURL=discoveryMechanism.d.ts.map

package/dist/prism/iterateAndCountTicks.d.ts

@@ -1,7 +1,7 @@
-import type { Pointer } from '../pointer';
-import type { Prism } from './Interface';
-export default function iterateAndCountTicks<V>(pointerOrPrism: Prism<V> | Pointer<V>): Generator<{
-    value: V;
-    ticks: number;
-}, void, void>;
-//# sourceMappingURL=iterateAndCountTicks.d.ts.map
+import type { Pointer } from '../pointer';
+import type { Prism } from './Interface';
+export default function iterateAndCountTicks<V>(pointerOrPrism: Prism<V> | Pointer<V>): Generator<{
+    value: V;
+    ticks: number;
+}, void, void>;
+//# sourceMappingURL=iterateAndCountTicks.d.ts.map

package/dist/prism/iterateOver.d.ts

@@ -1,4 +1,4 @@
-import type { Pointer } from '../pointer';
-import type { Prism } from './Interface';
-export default function iterateOver<V>(pointerOrPrism: Prism<V> | Pointer<V>): Generator<V, void, void>;
-//# sourceMappingURL=iterateOver.d.ts.map
+import type { Pointer } from '../pointer';
+import type { Prism } from './Interface';
+export default function iterateOver<V>(pointerOrPrism: Prism<V> | Pointer<V>): Generator<V, void, void>;
+//# sourceMappingURL=iterateOver.d.ts.map

package/dist/prism/iterateOver.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=iterateOver.test.d.ts.map

package/dist/prism/iterateOver.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"iterateOver.test.d.ts","sourceRoot":"","sources":["../../src/prism/iterateOver.test.ts"],"names":[],"mappings":""}

package/dist/prism/prism.d.ts

@@ -90,7 +90,7 @@ declare function state<T>(key: string, initialValue: T): [T, (val: T) => void];
  *
  * @example
  * ```ts
- * import {prism} from '@tomorrowevening/theatre-dataverse'
+ * import {prism} from '@theatre/dataverse'
  *
  * function onlyUsefulInAPrism() {
  *   prism.ensurePrism()

package/dist/prism/prism.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=prism.test.d.ts.map

package/dist/prism/prism.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prism.test.d.ts","sourceRoot":"","sources":["../../src/prism/prism.test.ts"],"names":[],"mappings":""}

package/dist/setupTestEnv.d.ts

@@ -1,2 +1,2 @@
-export {};
-//# sourceMappingURL=setupTestEnv.d.ts.map
+export {};
+//# sourceMappingURL=setupTestEnv.d.ts.map

package/dist/types.d.ts

@@ -1,6 +1,6 @@
-/** For `any`s that aren't meant to stay `any`*/
-export type $FixMe = any;
-/** For `any`s that we don't care about */
-export type $IntentionalAny = any;
-export type VoidFn = () => void;
-//# sourceMappingURL=types.d.ts.map
+/** For `any`s that aren't meant to stay `any`*/
+export type $FixMe = any;
+/** For `any`s that we don't care about */
+export type $IntentionalAny = any;
+export type VoidFn = () => void;
+//# sourceMappingURL=types.d.ts.map

package/dist/utils/Stack.d.ts

@@ -1,16 +1,16 @@
-interface Node<Data> {
-    next: undefined | Node<Data>;
-    data: Data;
-}
-/**
- * Just a simple LinkedList
- */
-export default class Stack<Data> {
-    _head: undefined | Node<Data>;
-    constructor();
-    peek(): Data | undefined;
-    pop(): Data | undefined;
-    push(data: Data): void;
-}
-export {};
-//# sourceMappingURL=Stack.d.ts.map
+interface Node<Data> {
+    next: undefined | Node<Data>;
+    data: Data;
+}
+/**
+ * Just a simple LinkedList
+ */
+export default class Stack<Data> {
+    _head: undefined | Node<Data>;
+    constructor();
+    peek(): Data | undefined;
+    pop(): Data | undefined;
+    push(data: Data): void;
+}
+export {};
+//# sourceMappingURL=Stack.d.ts.map

package/dist/utils/typeTestUtils.d.ts

@@ -1,11 +1,11 @@
-import type { $IntentionalAny } from '../types';
-/**
- * Useful in type tests, such as: const a: SomeType = _any
- */
-export declare const _any: $IntentionalAny;
-/**
- * Useful in typeTests. If you want to ensure that value v follows type V,
- * just write `expectType<V>(v)`
- */
-export declare const expectType: <T extends unknown>(v: T) => T;
-//# sourceMappingURL=typeTestUtils.d.ts.map
+import type { $IntentionalAny } from '../types';
+/**
+ * Useful in type tests, such as: const a: SomeType = _any
+ */
+export declare const _any: $IntentionalAny;
+/**
+ * Useful in typeTests. If you want to ensure that value v follows type V,
+ * just write `expectType<V>(v)`
+ */
+export declare const expectType: <T extends unknown>(v: T) => T;
+//# sourceMappingURL=typeTestUtils.d.ts.map

package/dist/utils/updateDeep.d.ts

@@ -1,3 +1,3 @@
-import type { $IntentionalAny } from '../types';
-export default function updateDeep<S>(state: S, path: (string | number | undefined)[], reducer: (...args: $IntentionalAny[]) => $IntentionalAny): S;
-//# sourceMappingURL=updateDeep.d.ts.map
+import type { $IntentionalAny } from '../types';
+export default function updateDeep<S>(state: S, path: (string | number | undefined)[], reducer: (...args: $IntentionalAny[]) => $IntentionalAny): S;
+//# sourceMappingURL=updateDeep.d.ts.map

package/dist/val.d.ts

@@ -1,14 +1,14 @@
-import type { Prism } from './prism/Interface';
-import type { PointerType } from './pointer';
-/**
- * Convenience function that returns a plain value from its argument, whether it
- * is a pointer, a prism or a plain value itself.
- *
- * @remarks
- * For pointers, the value is returned by first creating a prism, so it is
- * reactive e.g. when used in a `prism`.
- *
- * @param input - The argument to return a value from.
- */
-export declare const val: <P extends PointerType<any> | Prism<any> | null | undefined>(input: P) => P extends PointerType<infer T> ? T : P extends Prism<infer T_1> ? T_1 : P extends null | undefined ? P : unknown;
-//# sourceMappingURL=val.d.ts.map
+import type { Prism } from './prism/Interface';
+import type { PointerType } from './pointer';
+/**
+ * Convenience function that returns a plain value from its argument, whether it
+ * is a pointer, a prism or a plain value itself.
+ *
+ * @remarks
+ * For pointers, the value is returned by first creating a prism, so it is
+ * reactive e.g. when used in a `prism`.
+ *
+ * @param input - The argument to return a value from.
+ */
+export declare const val: <P extends Prism<any> | PointerType<any> | null | undefined>(input: P) => P extends PointerType<infer T> ? T : P extends Prism<infer T_1> ? T_1 : P extends null | undefined ? P : unknown;
+//# sourceMappingURL=val.d.ts.map

package/package.json

@@ -1,15 +1,15 @@
 {
   "name": "@tomorrowevening/theatre-dataverse",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "license": "Apache-2.0",
   "author": {
-    "name": "Colin Duffy",
-    "email": "colin@tomorrowevening.com",
-    "url": "https://tomorrowevening.com/"
+    "name": "Aria Minaei",
+    "email": "aria@theatrejs.com",
+    "url": "https://github.com/AriaMinaei"
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/tomorrowevening/theatre",
+    "url": "https://github.com/AriaMinaei/theatre",
     "directory": "packages/dataverse"
   },
   "main": "dist/index.js",
@@ -17,15 +17,12 @@
   "files": [
     "dist/**/*"
   ],
-  "publishConfig": {
-    "access": "public"
-  },
   "scripts": {
     "prepack": "node ../../devEnv/ensurePublishing.js",
     "typecheck": "yarn run build:ts",
     "build": "run-s build:ts build:js build:api-json",
     "build:ts": "tsc --build ./tsconfig.json",
-    "build:js": "tsx ./devEnv/build.ts",
+    "build:js": "node -r esbuild-register ./devEnv/build.ts",
     "build:api-json": "api-extractor run --local --config devEnv/api-extractor.json",
     "prepublish": "node ../../devEnv/ensurePublishing.js",
     "clean": "rm -rf ./dist && rm -f tsconfig.tsbuildinfo",
@@ -38,8 +35,8 @@
     "@types/lodash-es": "^4.17.4",
     "@types/node": "^15.6.2",
     "esbuild": "^0.12.15",
+    "esbuild-register": "^2.5.0",
     "npm-run-all": "^4.1.5",
-    "tsx": "4.7.0",
     "typedoc": "^0.24.8",
     "typedoc-plugin-markdown": "^3.15.4",
     "typescript": "5.1.6"