@data-weave/datamanager 0.4.2 → 0.4.3

package/lib/Cache.d.ts

@@ -0,0 +1,15 @@
+export interface Cache<K = any, V = any> {
+    get(key: K): V | undefined;
+    set(key: K, value: V): void;
+    has(key: K): boolean;
+}
+export declare class MapCache<K, V> implements Cache<K, V> {
+    private cache;
+    private maxSize?;
+    constructor(maxSize?: number);
+    get(key: K): V | undefined;
+    set(key: K, value: V): void;
+    has(key: K): boolean;
+    delete(key: K): boolean;
+    clear(): void;
+}

package/lib/Cache.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MapCache = void 0;
+class MapCache {
+    constructor(maxSize) {
+        this.cache = new Map();
+        this.maxSize = maxSize;
+    }
+    get(key) {
+        return this.cache.get(key);
+    }
+    set(key, value) {
+        if (this.maxSize && this.cache.size >= this.maxSize && !this.cache.has(key)) {
+            // Remove the first entry (oldest) when cache is full
+            const firstKey = this.cache.keys().next().value;
+            if (firstKey) {
+                this.cache.delete(firstKey);
+            }
+        }
+        this.cache.set(key, value);
+    }
+    has(key) {
+        return this.cache.has(key);
+    }
+    delete(key) {
+        return this.cache.delete(key);
+    }
+    clear() {
+        this.cache.clear();
+    }
+}
+exports.MapCache = MapCache;

package/lib/DataManager.d.ts

@@ -0,0 +1,42 @@
+import { List } from './List';
+import { IdentifiableReference, WithoutId } from './Reference';
+export interface ReadOptions {
+    readonly transaction?: unknown;
+}
+export interface WriteOptions {
+    readonly transaction?: unknown;
+    readonly batcher?: unknown;
+}
+export interface CreateOptions extends WriteOptions {
+    id?: string;
+    merge?: boolean;
+}
+export type OrderByOption = 'asc' | 'desc';
+export interface GetListOptions {
+    readonly filterBy?: unknown;
+    readonly orderBy?: unknown;
+    readonly limit?: number;
+}
+export interface Metadata {
+    readonly id: string;
+    readonly createdAt: Date;
+    readonly updatedAt: Date;
+    readonly deleted: boolean;
+}
+export type WithMetadata<T> = T & Metadata;
+/**
+ * DataManager is the base class for all data managers.
+ * It is responsible for reading, creating, deleting, and updating data.
+ * It is also responsible for returning references and lists.
+ * It is generic and can be used for any type of data.
+ * @template T - The type of the data to be managed.
+ */
+export declare abstract class DataManager<T> {
+    abstract read(id: string): Promise<T | undefined>;
+    abstract create(data: WithoutId<T>, options?: CreateOptions): Promise<IdentifiableReference<WithMetadata<T>>>;
+    abstract delete(id: string): Promise<void>;
+    abstract update(id: string, data: Partial<WithoutId<T>>): Promise<void>;
+    abstract upsert(id: string, data: WithoutId<T>): Promise<void>;
+    abstract getRef(id: string): IdentifiableReference<WithMetadata<T>>;
+    abstract getList(params?: GetListOptions): List<WithMetadata<T>>;
+}

package/lib/DataManager.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataManager = void 0;
+/**
+ * DataManager is the base class for all data managers.
+ * It is responsible for reading, creating, deleting, and updating data.
+ * It is also responsible for returning references and lists.
+ * It is generic and can be used for any type of data.
+ * @template T - The type of the data to be managed.
+ */
+class DataManager {
+}
+exports.DataManager = DataManager;

package/lib/List.d.ts

@@ -0,0 +1,11 @@
+import { Resolvable } from './Reference';
+export interface ListPaginationParams {
+    readonly pageSize?: number;
+    readonly append?: boolean;
+    readonly loadFirstPageManually?: boolean;
+}
+export interface List<T> extends Resolvable<readonly T[]> {
+    readonly values: readonly T[];
+}
+export declare function createInitializedList<T>(values: ReadonlyArray<T>): List<T>;
+export declare function createEmptyList<T>(): List<T>;

package/lib/List.js

@@ -0,0 +1,24 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createInitializedList = createInitializedList;
+exports.createEmptyList = createEmptyList;
+function createInitializedList(values) {
+    return {
+        values,
+        resolved: true,
+        hasError: false,
+        resolve: () => __awaiter(this, void 0, void 0, function* () { return values; }),
+    };
+}
+function createEmptyList() {
+    return createInitializedList([]);
+}

package/lib/LiveList.d.ts

@@ -0,0 +1,24 @@
+import { List } from './List';
+export interface LiveListOptions<T> {
+    onUpdate?: (newValues: T[]) => void;
+    onError?: (error: unknown) => void;
+}
+export declare class LiveList<T> implements List<T> {
+    private _values;
+    private _resolved;
+    private _hasError;
+    private _options;
+    constructor(options: LiveListOptions<T>);
+    resolve(): Promise<readonly T[]>;
+    get values(): T[];
+    get hasError(): boolean;
+    get resolved(): boolean;
+    protected setStale(): void;
+    protected onValuesChange(): void;
+    protected onUpdate(): void;
+    protected onUpdateAll(values: T[]): void;
+    protected onUpdateAtIndex(index: number, value: T): void;
+    protected onAddAtIndex(index: number, value: T): void;
+    protected onRemoveAtIndex(index: number): void;
+    protected onError(error: unknown): void;
+}

package/lib/LiveList.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LiveList = void 0;
+class LiveList {
+    constructor(options) {
+        this._values = [];
+        this._resolved = false;
+        this._hasError = false;
+        this._options = options;
+    }
+    resolve() {
+        throw new Error('Method not implemented.');
+    }
+    get values() {
+        return this._values;
+    }
+    get hasError() {
+        return this._hasError;
+    }
+    get resolved() {
+        return this._resolved;
+    }
+    setStale() {
+        this._resolved = false;
+    }
+    onValuesChange() { }
+    onUpdate() {
+        var _a, _b;
+        this._resolved = true;
+        this.onValuesChange();
+        (_b = (_a = this._options).onUpdate) === null || _b === void 0 ? void 0 : _b.call(_a, this._values);
+    }
+    onUpdateAll(values) {
+        this._values = values;
+        this.onUpdate();
+    }
+    onUpdateAtIndex(index, value) {
+        this._values[index] = value;
+    }
+    onAddAtIndex(index, value) {
+        this._values.splice(index, 0, value);
+    }
+    onRemoveAtIndex(index) {
+        this._values.splice(index, 1);
+    }
+    onError(error) {
+        var _a, _b;
+        this._hasError = true;
+        this._values = [];
+        this._resolved = true;
+        (_b = (_a = this._options).onError) === null || _b === void 0 ? void 0 : _b.call(_a, error);
+        this.onValuesChange();
+    }
+}
+exports.LiveList = LiveList;

package/lib/LiveReference.d.ts

@@ -0,0 +1,21 @@
+import { Reference } from './Reference';
+export interface LiveReferenceOptions<T> {
+    onUpdate?: (newValue: T | undefined) => void;
+    onError?: (error: unknown) => void;
+}
+export declare class LiveReference<T> implements Reference<T> {
+    readonly options: LiveReferenceOptions<T>;
+    private _value;
+    private _resolved;
+    private _hasError;
+    private _options;
+    resolve(): Promise<T | undefined>;
+    constructor(options: LiveReferenceOptions<T>);
+    get value(): T | undefined;
+    get resolved(): boolean;
+    get hasError(): boolean;
+    protected setStale(): void;
+    protected onUpdate(data: T | undefined): void;
+    protected onError(error: unknown): void;
+    protected onValueChange(): void;
+}

package/lib/LiveReference.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LiveReference = void 0;
+class LiveReference {
+    resolve() {
+        throw new Error('Method not implemented.');
+    }
+    constructor(options) {
+        this.options = options;
+        this._resolved = false;
+        this._hasError = false;
+        this._value = undefined;
+        this._resolved = false;
+        this._hasError = false;
+        this._options = options;
+    }
+    get value() {
+        return this._value;
+    }
+    get resolved() {
+        return this._resolved;
+    }
+    get hasError() {
+        return this._hasError;
+    }
+    setStale() {
+        this._resolved = false;
+    }
+    onUpdate(data) {
+        var _a, _b;
+        this._value = data;
+        this._resolved = true;
+        this.onValueChange();
+        (_b = (_a = this._options).onUpdate) === null || _b === void 0 ? void 0 : _b.call(_a, this._value);
+    }
+    onError(error) {
+        var _a, _b;
+        this._hasError = true;
+        this._value = undefined;
+        this._resolved = true;
+        this.onValueChange();
+        (_b = (_a = this._options).onError) === null || _b === void 0 ? void 0 : _b.call(_a, error);
+    }
+    onValueChange() { }
+}
+exports.LiveReference = LiveReference;

package/lib/Reference.d.ts

@@ -0,0 +1,15 @@
+export interface Identifiable {
+    readonly id: string;
+}
+export type WithoutId<T> = Omit<T, 'id'>;
+export interface Resolvable<T> {
+    readonly resolved: boolean;
+    readonly hasError: boolean;
+    resolve(): Promise<T>;
+}
+export interface Reference<T> extends Resolvable<T | undefined> {
+    readonly value: T | undefined;
+}
+export type IdentifiableReference<T> = Reference<T> & Identifiable;
+export declare function createInitializedIdentifiableReference<T>(value: T | undefined, id: string): Reference<T> & Identifiable;
+export declare function createEmptyIdentifiableReference<T>(id: string): Reference<T>;

package/lib/Reference.js

@@ -0,0 +1,25 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createInitializedIdentifiableReference = createInitializedIdentifiableReference;
+exports.createEmptyIdentifiableReference = createEmptyIdentifiableReference;
+function createInitializedIdentifiableReference(value, id) {
+    return {
+        id,
+        value,
+        resolved: true,
+        hasError: false,
+        resolve: () => __awaiter(this, void 0, void 0, function* () { return value; }),
+    };
+}
+function createEmptyIdentifiableReference(id) {
+    return createInitializedIdentifiableReference(undefined, id);
+}

package/lib/index.d.ts

@@ -0,0 +1,6 @@
+export * from './Cache';
+export * from './DataManager';
+export * from './List';
+export * from './LiveList';
+export * from './LiveReference';
+export * from './Reference';

package/lib/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Cache"), exports);
+__exportStar(require("./DataManager"), exports);
+__exportStar(require("./List"), exports);
+__exportStar(require("./LiveList"), exports);
+__exportStar(require("./LiveReference"), exports);
+__exportStar(require("./Reference"), exports);

package/lib/version.js

@@ -1,2 +1,2 @@
 // Generated by genversion.
-module.exports = '0.4.2';
+module.exports = '0.4.3';

package/package.json

@@ -1,11 +1,15 @@
 {
     "name": "@data-weave/datamanager",
-    "version": "0.4.2",
+    "version": "0.4.3",
     "author": "",
     "main": "lib/index.js",
     "types": "lib/index.d.ts",
+    "files": [
+        "lib/**/*.js",
+        "lib/**/*.d.ts"
+    ],
     "scripts": {
-        "build": "genversion --semi lib/version.js",
+        "build": "genversion --semi lib/version.js && cp -r ../../build/datamanager/lib/*.js lib/ && cp -r ../../build/types/datamanager/lib/*.d.ts lib/",
         "build:clean": "rimraf android/build && rimraf ios/build",
         "prepare": "npm run build"
     },
@@ -17,5 +21,5 @@
         "access": "public",
         "registry": "https://registry.npmjs.org/"
     },
-    "gitHead": "1dcdcb73b691bdeaa60f9a7dd3ada171fde24f32"
+    "gitHead": "5dd7dfd873ebb8a0b8a11870fac08f41d9548aa7"
 }

package/CHANGELOG.md

@@ -1,62 +0,0 @@
-# Change Log
-
-All notable changes to this project will be documented in this file.
-See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
-
-## [0.4.2](https://github.com/data-weave/datamanager/compare/v0.4.1...v0.4.2) (2025-10-15)
-
-**Note:** Version bump only for package @data-weave/datamanager
-
-## [0.4.1](https://github.com/data-weave/datamanager/compare/v0.4.0...v0.4.1) (2025-10-15)
-
-**Note:** Version bump only for package @data-weave/datamanager
-
-## [0.4.0](https://github.com/data-weave/datamanager/compare/v0.3.8...v0.4.0) (2025-10-15)
-
-**Note:** Version bump only for package @data-weave/datamanager
-
-## [0.3.8](https://github.com/data-weave/datamanager/compare/v0.3.7...v0.3.8) (2025-09-28)
-
-**Note:** Version bump only for package @data-weave/datamanager
-
-## [0.3.7](https://github.com/data-weave/datamanager/compare/v0.3.6...v0.3.7) (2025-09-28)
-
-**Note:** Version bump only for package @data-weave/datamanager
-
-## [0.3.6](https://github.com/data-weave/datamanager/compare/v0.3.5...v0.3.6) (2025-09-28)
-
-**Note:** Version bump only for package @data-weave/datamanager
-
-## [0.3.5](https://github.com/data-weave/datamanager/compare/v0.3.4...v0.3.5) (2025-09-28)
-
-**Note:** Version bump only for package @data-weave/datamanager
-
-## [0.3.4](https://github.com/data-weave/datamanager/compare/v0.3.3...v0.3.4) (2025-09-28)
-
-**Note:** Version bump only for package @data-weave/datamanager
-
-## [0.3.2](https://github.com/data-weave/datamanager/compare/v0.3.1...v0.3.2) (2025-09-28)
-
-**Note:** Version bump only for package @data-weave/datamanager
-
-## [0.3.1](https://github.com/data-weave/datamanager/compare/v0.3.0...v0.3.1) (2025-09-28)
-
-**Note:** Version bump only for package @data-weave/datamanager
-
-## 0.3.0 (2025-09-28)
-
-### Features
-
-- add code quality workflow and circular dep check ([9c7b7e3](https://github.com/data-weave/datamanager/commit/9c7b7e34501dfc95ddc2bcff686f55db06d9b1b8))
-- project re-organization ([4a00af3](https://github.com/data-weave/datamanager/commit/4a00af36c4c2f6e49287542e0d5ad85acaa50cda))
-
-### Bug Fixes
-
-- adjust config and lib versions ([9c7e2c9](https://github.com/data-weave/datamanager/commit/9c7e2c9072ea34b1e54326c2612b43c92ec2da4e))
-- implement Cache prop & clean up some of anys ([955b11a](https://github.com/data-weave/datamanager/commit/955b11a6ab05224f843db834ad28796602679fac))
-
-### Code Refactoring
-
-- abstract out firestoreReference into LiveReference ([7848a87](https://github.com/data-weave/datamanager/commit/7848a872155593e5acab56696d4d9f27f0e6abb2))
-- abstract out LiveList function from FirestorList ([bb4278e](https://github.com/data-weave/datamanager/commit/bb4278e960d0080d1fb18d847036acb189782ec9))
-- adjustments for LiveList & ListReference ([49cd540](https://github.com/data-weave/datamanager/commit/49cd540295693e40bbb9eb75b5101b45c6932921))

package/lib/Cache.ts

@@ -1,41 +0,0 @@
-export interface Cache<K = any, V = any> {
-    get(key: K): V | undefined
-    set(key: K, value: V): void
-    has(key: K): boolean
-}
-
-export class MapCache<K, V> implements Cache<K, V> {
-    private cache = new Map<K, V>()
-    private maxSize?: number
-
-    constructor(maxSize?: number) {
-        this.maxSize = maxSize
-    }
-
-    get(key: K): V | undefined {
-        return this.cache.get(key)
-    }
-
-    set(key: K, value: V): void {
-        if (this.maxSize && this.cache.size >= this.maxSize && !this.cache.has(key)) {
-            // Remove the first entry (oldest) when cache is full
-            const firstKey = this.cache.keys().next().value
-            if (firstKey) {
-                this.cache.delete(firstKey)
-            }
-        }
-        this.cache.set(key, value)
-    }
-
-    has(key: K): boolean {
-        return this.cache.has(key)
-    }
-
-    delete(key: K): boolean {
-        return this.cache.delete(key)
-    }
-
-    clear(): void {
-        this.cache.clear()
-    }
-}

package/lib/DataManager.ts

@@ -1,50 +0,0 @@
-import { List } from './List'
-import { IdentifiableReference, WithoutId } from './Reference'
-
-export interface ReadOptions {
-    readonly transaction?: unknown
-}
-
-export interface WriteOptions {
-    readonly transaction?: unknown
-    readonly batcher?: unknown
-}
-
-export interface CreateOptions extends WriteOptions {
-    id?: string
-    merge?: boolean
-}
-
-export type OrderByOption = 'asc' | 'desc'
-
-export interface GetListOptions {
-    readonly filterBy?: unknown
-    readonly orderBy?: unknown
-    readonly limit?: number
-}
-
-export interface Metadata {
-    readonly id: string
-    readonly createdAt: Date
-    readonly updatedAt: Date
-    readonly deleted: boolean
-}
-
-export type WithMetadata<T> = T & Metadata
-/**
- * DataManager is the base class for all data managers.
- * It is responsible for reading, creating, deleting, and updating data.
- * It is also responsible for returning references and lists.
- * It is generic and can be used for any type of data.
- * @template T - The type of the data to be managed.
- */
-export abstract class DataManager<T> {
-    public abstract read(id: string): Promise<T | undefined>
-    public abstract create(data: WithoutId<T>, options?: CreateOptions): Promise<IdentifiableReference<WithMetadata<T>>>
-    public abstract delete(id: string): Promise<void>
-    public abstract update(id: string, data: Partial<WithoutId<T>>): Promise<void>
-    public abstract upsert(id: string, data: WithoutId<T>): Promise<void>
-
-    public abstract getRef(id: string): IdentifiableReference<WithMetadata<T>>
-    public abstract getList(params?: GetListOptions): List<WithMetadata<T>>
-}

package/lib/List.ts

@@ -1,24 +0,0 @@
-import { Resolvable } from './Reference'
-
-export interface ListPaginationParams {
-    readonly pageSize?: number
-    readonly append?: boolean
-    readonly loadFirstPageManually?: boolean
-}
-
-export interface List<T> extends Resolvable<readonly T[]> {
-    readonly values: readonly T[]
-}
-
-export function createInitializedList<T>(values: ReadonlyArray<T>): List<T> {
-    return {
-        values,
-        resolved: true,
-        hasError: false,
-        resolve: async () => values,
-    }
-}
-
-export function createEmptyList<T>(): List<T> {
-    return createInitializedList([])
-}

package/lib/LiveList.ts

@@ -1,70 +0,0 @@
-import { List } from './List'
-
-export interface LiveListOptions<T> {
-    onUpdate?: (newValues: T[]) => void
-    onError?: (error: unknown) => void
-}
-
-export class LiveList<T> implements List<T> {
-    private _values: T[] = []
-    private _resolved: boolean = false
-    private _hasError: boolean = false
-    private _options: LiveListOptions<T>
-
-    constructor(options: LiveListOptions<T>) {
-        this._options = options
-    }
-
-    resolve(): Promise<readonly T[]> {
-        throw new Error('Method not implemented.')
-    }
-
-    public get values() {
-        return this._values
-    }
-
-    public get hasError() {
-        return this._hasError
-    }
-
-    public get resolved() {
-        return this._resolved
-    }
-
-    protected setStale() {
-        this._resolved = false
-    }
-
-    protected onValuesChange(): void {}
-
-    protected onUpdate(): void {
-        this._resolved = true
-        this.onValuesChange()
-        this._options.onUpdate?.(this._values)
-    }
-
-    protected onUpdateAll(values: T[]): void {
-        this._values = values
-        this.onUpdate()
-    }
-
-    protected onUpdateAtIndex(index: number, value: T): void {
-        this._values[index] = value
-    }
-
-    protected onAddAtIndex(index: number, value: T): void {
-        this._values.splice(index, 0, value)
-    }
-
-    protected onRemoveAtIndex(index: number): void {
-        this._values.splice(index, 1)
-    }
-
-    protected onError(error: unknown): void {
-        this._hasError = true
-        this._values = []
-        this._resolved = true
-        this._options.onError?.(error)
-        this.onValuesChange()
-    }
-}

package/lib/LiveReference.ts

@@ -1,57 +0,0 @@
-import { Reference } from './Reference'
-
-export interface LiveReferenceOptions<T> {
-    onUpdate?: (newValue: T | undefined) => void
-    onError?: (error: unknown) => void
-}
-
-export class LiveReference<T> implements Reference<T> {
-    private _value: T | undefined
-    private _resolved: boolean = false
-    private _hasError: boolean = false
-    private _options: LiveReferenceOptions<T>
-
-    resolve(): Promise<T | undefined> {
-        throw new Error('Method not implemented.')
-    }
-
-    constructor(readonly options: LiveReferenceOptions<T>) {
-        this._value = undefined
-        this._resolved = false
-        this._hasError = false
-        this._options = options
-    }
-
-    public get value(): T | undefined {
-        return this._value
-    }
-
-    public get resolved() {
-        return this._resolved
-    }
-
-    public get hasError() {
-        return this._hasError
-    }
-
-    protected setStale() {
-        this._resolved = false
-    }
-
-    protected onUpdate(data: T | undefined): void {
-        this._value = data
-        this._resolved = true
-        this.onValueChange()
-        this._options.onUpdate?.(this._value)
-    }
-
-    protected onError(error: unknown) {
-        this._hasError = true
-        this._value = undefined
-        this._resolved = true
-        this.onValueChange()
-        this._options.onError?.(error)
-    }
-
-    protected onValueChange(): void {}
-}

package/lib/Reference.ts

@@ -1,34 +0,0 @@
-export interface Identifiable {
-    readonly id: string
-}
-
-export type WithoutId<T> = Omit<T, 'id'>
-
-export interface Resolvable<T> {
-    readonly resolved: boolean
-    readonly hasError: boolean
-    resolve(): Promise<T>
-}
-
-export interface Reference<T> extends Resolvable<T | undefined> {
-    readonly value: T | undefined
-}
-
-export type IdentifiableReference<T> = Reference<T> & Identifiable
-
-export function createInitializedIdentifiableReference<T>(
-    value: T | undefined,
-    id: string
-): Reference<T> & Identifiable {
-    return {
-        id,
-        value,
-        resolved: true,
-        hasError: false,
-        resolve: async () => value,
-    }
-}
-
-export function createEmptyIdentifiableReference<T>(id: string): Reference<T> {
-    return createInitializedIdentifiableReference<T>(undefined, id)
-}

package/lib/index.ts

@@ -1,6 +0,0 @@
-export * from './Cache'
-export * from './DataManager'
-export * from './List'
-export * from './LiveList'
-export * from './LiveReference'
-export * from './Reference'