@omegup/msync 0.0.44 → 0.0.46

package/lib/watch.d.ts

@@ -1,15 +0,0 @@
-import type { BSON, Db, Timestamp } from 'mongodb';
-import type { O, StrKey, View } from '../types';
-import { type Field } from './field';
-import type { Model, Query } from './types';
-export declare const changeKeys: readonly ["fullDocument", "fullDocumentBeforeChange"];
-export type ChangeKey = (typeof changeKeys)[number];
-export type Change<T extends Model> = O<{
-    readonly fullDocument: T;
-    readonly fullDocumentBeforeChange: T;
-}>;
-export declare const subQ: <D extends O, C, DeltaD extends O>(a: Query<D, C>, f: Field<DeltaD, D>) => Query<DeltaD, C>;
-export declare const makeWatchStream: <V extends Model, K extends StrKey<V>>(db: Db, { collection, projection: p, hardMatch: m }: View<V, K>, startAt: Timestamp, streamName: string) => {
-    tryNext: () => Promise<import("mongodb").ChangeStreamDocument<BSON.Document> | null>;
-    close: () => Promise<void>;
-};

package/test/mongodb.d.ts

@@ -1,9 +0,0 @@
-import { Collection, MongoClient } from 'mongodb';
-import type { AsynIter, Iterator } from '../lib/types';
-import type { ID, doc } from '../types';
-import type { Db, OptionalUnlessRequiredId } from 'mongodb';
-export declare const run: <T, Info>(cont: Iterator<T, Info>) => Promise<never>;
-export declare const iterate: <T>([, next]: AsynIter<T>) => PromiseLike<never>;
-export declare const enablePreAndPostImages: <T extends doc>(coll: Collection<T>) => Promise<import("mongodb").Document>;
-export declare const prepare: (testName?: string) => Promise<MongoClient>;
-export declare const makeCol: <T extends ID>(docs: readonly OptionalUnlessRequiredId<T>[], database: Db, name?: string) => Promise<Collection<T>>;

package/test/uri.d.ts

@@ -1 +0,0 @@
-export declare const uri: string;

package/types/class.d.ts

@@ -1 +0,0 @@
-export declare const Type: unique symbol;

package/types/extern.d.ts

@@ -1,3 +0,0 @@
-export type { Type } from './class';
-export type { Arr, ID, N, O, Rec, StrKey, doc, OPick, OPickD, RORec, Replace } from './index';
-export type { AsLiteral, notArr, WriteonlyCollection, Collection, Timestamp } from './index';

package/types/global.d.ts

@@ -1,50 +0,0 @@
-import type { App, AppMap, AppMapRW, HKT, PromiseHKT } from './hkt';
-import type { RORec, StrKey } from './json';
-export type AsNum<R> = R extends `${infer A extends number}` ? A : never;
-export type GetDom<Dom = unknown> = readonly [readonly Dom[], keyof any];
-declare global {
-    type Entry<T, K extends keyof T = keyof T> = readonly [string, T[string & K]] & {
-        [k in K]: readonly [string & k, T[k]];
-    }[K];
-    interface ObjectConstructor {
-        entries<T, _ = 0>(object?: T): readonly Entry<T>[];
-        fromEntries<T, _ = 0>(entries: readonly Entry<T>[]): T;
-        keys<T, _ extends 1>(obj: T): readonly StrKey<T>[];
-    }
-    interface ReadonlyArray<T> {
-        includes<T, V extends T>(this: ReadonlyArray<V>, item: T, fromIndex?: number): item is V;
-        map<U>(callbackfn: (value: T, index: number, array: readonly T[]) => U, thisArg?: any): U[];
-        map<K extends string, T extends RORec<K>, U extends RORec<K>, _ extends 2 = 2>(this: readonly Entry<T, K>[], callbackfn: <P extends K>(value: [P, T[P]], index: number, array: this) => readonly [P, U[P]], thisArg?: any): readonly Entry<U, K>[];
-        map<V extends ReadonlyArray<unknown>, F extends HKT<unknown>, G extends HKT<unknown>, _ extends 1 = 1>(this: AppMap<F, V>, callbackfn: <I extends keyof V>(value: App<F, V[I]>, index: AsNum<I>, array: V) => App<G, V[I]>, thisArg?: any): AppMapRW<G, V>;
-        reduce<U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: readonly T[]) => U, initialValue: U): U;
-        reduce<V extends ReadonlyArray<unknown>, F extends HKT, U>(this: AppMap<F, V>, callbackfn: <I extends keyof V>(previousValue: U, currentValue: App<F, V[I]>, currentIndex: AsNum<I>, array: V) => U, initialValue: U): U;
-        map<V extends ReadonlyArray<Dom>, F extends HKT<Dom>, G extends HKT<GetDom<Dom>>, Dom = unknown, _ extends 0 = 0>(this: AppMap<F, V, Dom>, callbackfn: <I extends keyof V>(value: App<F, V[I] & Dom>, index: AsNum<I>, array: V) => App<G, [V, I]>, thisArg?: any): AppMapRW<G, {
-            [I in keyof V]: [V, I];
-        }, GetDom<Dom>>;
-    }
-    interface Array<T> extends ReadonlyArray<T> {
-        includes<T, V extends T>(this: ReadonlyArray<V>, item: T, fromIndex?: number): item is V;
-        map<U>(callbackfn: (value: T, index: number, array: readonly T[]) => U, thisArg?: any): U[];
-        map<K extends string, T extends RORec<K>, U extends RORec<K>, _ extends 2 = 2>(this: readonly Entry<T, K>[], callbackfn: <P extends K>(value: [P, T[P]], index: number, array: this) => readonly [P, U[P]], thisArg?: any): readonly Entry<U, K>[];
-        map<V extends ReadonlyArray<unknown>, F extends HKT<unknown>, G extends HKT<unknown>, _ extends 1 = 1>(this: AppMap<F, V>, callbackfn: <I extends keyof V>(value: App<F, V[I]>, index: AsNum<I>, array: V) => App<G, V[I]>, thisArg?: any): AppMapRW<G, V>;
-        reduce<U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: readonly T[]) => U, initialValue: U): U;
-        reduce<V extends ReadonlyArray<unknown>, F extends HKT, U>(this: AppMap<F, V>, callbackfn: <I extends keyof V>(previousValue: U, currentValue: App<F, V[I]>, currentIndex: AsNum<I>, array: V) => U, initialValue: U): U;
-        map<V extends ReadonlyArray<Dom>, F extends HKT<Dom>, G extends HKT<GetDom<Dom>>, Dom = unknown, _ extends 0 = 0>(this: AppMap<F, V, Dom>, callbackfn: <I extends keyof V>(value: App<F, V[I] & Dom>, index: AsNum<I>, array: V) => App<G, [V, I]>, thisArg?: any): AppMapRW<G, {
-            [I in keyof V]: [V, I];
-        }, GetDom<Dom>>;
-    }
-    interface PromiseConstructor {
-        all<T extends readonly unknown[] | []>(values: AppMap<PromiseHKT, T>): Promise<T>;
-        race<T extends readonly unknown[] | [], _ extends 0 = 0>(values: AppMap<PromiseHKT, T>): Promise<T[number]>;
-        all<T extends readonly unknown[] | []>(values: T): Promise<{
-            -readonly [P in keyof T]: Awaited<T[P]>;
-        }>;
-        race<T extends readonly unknown[] | []>(values: T): Promise<Awaited<T[number]>>;
-    }
-}
-declare module 'synchronous-promise' {
-    interface SynchronousPromiseConstructor {
-        any<T extends readonly unknown[] | [], _ extends 0 = 0>(values: AppMap<PromiseHKT, T>): SynchronousPromise<T[number]>;
-        any<T extends readonly unknown[] | []>(values: T): SynchronousPromise<Awaited<T[number]>>;
-    }
-}

package/types/hkt.d.ts

@@ -1,56 +0,0 @@
-import type { UBefore } from "../lib/types";
-import type { Rec } from "./json";
-export interface HKT<in Dom = unknown, out Im = unknown> {
-    readonly in: (x: Dom) => void;
-    readonly out: Im;
-}
-export type App<F extends HKT<X>, X> = (F & {
-    readonly in: (x: X) => void;
-})['out'];
-export type I<Dom, F extends HKT<Dom>> = F['in'] extends (x: infer X extends Dom) => void ? X : never;
-export interface ArrHKT<Dom = unknown> extends HKT<Dom> {
-    readonly out: readonly I<Dom, this>[];
-}
-export interface IdHKT<Dom = unknown> extends HKT<Dom> {
-    readonly out: I<Dom, this>;
-}
-export interface RConstHKT<Im, Dom = Im> extends HKT<Im, HKT<Dom, Im>> {
-    readonly out: ConstHKT<I<Im, this>, Dom>;
-}
-export interface ConstHKT<Im, Dom = unknown> extends HKT<Dom, Im> {
-    readonly out: Im;
-}
-type ApplyF<Dom, Im, T extends [Dom, HKT<Dom, Im>]> = App<T[1], T[0]>;
-export interface ApplyHKT<Dom, Im> extends HKT<[Dom, HKT<Dom, Im>], Im> {
-    readonly out: ApplyF<Dom, Im, I<[Dom, HKT<Dom, Im>], this>>;
-}
-export interface µ<X extends [HKT<A, B>, HKT<B, C>], A = unknown, B = unknown, C = unknown> extends HKT<A, C> {
-    readonly out: App<X[1], App<X[0], I<A, this>>>;
-}
-export type AppMap<F extends HKT<Dom>, X extends readonly Dom[], Dom = unknown> = readonly App<F, Dom>[] & {
-    [I in keyof X]: App<F, X[I]>;
-};
-export type AppMapRW<F extends HKT<Dom>, X extends readonly Dom[], Dom = unknown> = App<F, Dom>[] & {
-    [I in keyof X]: App<F, X[I]>;
-};
-export interface PromiseHKT<Dom = unknown> extends HKT<Dom> {
-    readonly out: PromiseLike<I<Dom, this>>;
-}
-export interface DeepFieldHKT<R, T, K extends keyof T, F extends HKT<R, T>> extends HKT<R, T[K]> {
-    readonly out: App<F, I<R, this>>[K];
-}
-export interface FieldHKT<K extends string> extends DeepFieldHKT<Record<K, unknown>, Record<K, unknown>, K, IdHKT<Record<K, unknown>>> {
-}
-export interface RecordHKT<K extends string, Dom = unknown> extends HKT<Dom, Record<K, Dom>> {
-    readonly out: Record<K, I<Dom, this>>;
-}
-export interface RecHKT<K extends string, Dom = unknown, E = unknown> extends HKT<Dom, Rec<K, Dom>> {
-    readonly out: Rec<K, I<Dom, this>> & E;
-}
-export interface UBeforeHKT<Dom = unknown> extends HKT<Dom, UBefore<Dom>> {
-    readonly out: UBefore<I<Dom, this>>;
-}
-export interface And<E> extends HKT {
-    readonly out: E & I<unknown, this>;
-}
-export {};

package/types/index.d.ts

@@ -1,6 +0,0 @@
-export * from './global';
-export * from './json';
-export * from './hkt';
-export * from './class';
-export * from './view';
-export * from './mongo';

package/types/json.d.ts

@@ -1,54 +0,0 @@
-import type { Timestamp } from 'mongodb';
-import { Type } from './class';
-export { Type } from './class';
-export type U = undefined;
-export type N = null | U;
-export type jsonPrim = number | null | string | boolean | Timestamp | Date;
-export type notObj = jsonPrim | U;
-export type notArr = notObj | O;
-export type jsonItem = unknown;
-export type rawItem = jsonPrim | raw | U;
-export type Undef<I extends N> = I | (I extends never ? I : notObj);
-export declare const object: unique symbol;
-export declare const array: unique symbol;
-export interface JsonArr {
-    [Type]: typeof array;
-    readonly [_: number]: jsonItem | U;
-}
-export type A = {
-    [Type]: typeof array;
-};
-export type Arr<T, N extends number = number> = A & {
-    readonly [_ in N]: T;
-};
-type Obj = {
-    [Type]: typeof object;
-};
-export type O<T = unknown> = Obj & T;
-export type RORec<K extends keyof never, T = unknown> = {
-    readonly [P in K]: T;
-};
-export type Par<K extends string, V extends Rec<K, jsonItem>> = {
-    readonly [k in K]?: V[k] | N;
-};
-export type Rec<K extends string, T = unknown> = O<RORec<K, T>>;
-export type O2 = readonly [O, O];
-export type O3 = readonly [O, O, O];
-export type ID = {
-    readonly _id: string;
-};
-export type doc = O & ID;
-export interface RawObj {
-    readonly [_: string]: rawItem | U;
-}
-export type raw = readonly rawItem[] | RawObj;
-export type StrKey<T> = string & keyof T;
-export type Replace<R, V> = Omit<R, StrKey<V>> & V & O;
-export type AsLiteral<T extends keyof any | boolean, V = NoUnion<T>> = T extends keyof any ? {} extends {
-    [K in T]: 1;
-} ? never : V : V;
-type NoUnion<T, V = T> = T extends unknown ? ([V] extends [T] ? T : never) : never;
-export type Literal<K> = string extends K ? never : K;
-export type RemoveSignature<T> = {
-    [K in keyof T as Literal<K>]: T[K];
-};

package/types/mongo.d.ts

@@ -1,24 +0,0 @@
-import 'mongodb';
-import { BSON } from 'mongodb';
-export declare const RawStage: unique symbol;
-declare module 'mongodb' {
-    interface Collection<TSchema extends BSON.Document = BSON.Document> {
-        [RawStage]: {
-            (_: 2): TSchema;
-            (_: 1, x: TSchema): TSchema;
-        };
-        s: {
-            db: Db;
-        };
-    }
-    interface Db {
-        s: {
-            client?: MongoClient;
-        };
-        client: MongoClient;
-    }
-    interface Timestamp {
-        toExtendedJSON(): BSON.TimestampExtended;
-    }
-}
-export * from 'mongodb';

package/types/view.d.ts

@@ -1,35 +0,0 @@
-import type { Collection, Db } from 'mongodb';
-import type { Del, Expr, Model, Query } from '../lib/types';
-import type { ExactKeys } from '../lib/utils/map-object';
-import type { O, StrKey } from './json';
-import type { RawStage } from './mongo';
-interface CommonCollection {
-    readonly s: {
-        readonly db: Db;
-    };
-    collectionName: string;
-    namespace: string;
-    dbName: string;
-    createIndex: Collection['createIndex'];
-}
-export interface ReadonlyCollection<out Out> extends CommonCollection {
-    [RawStage](_: 2): Out;
-}
-export interface WriteonlyCollection<in R> extends CommonCollection {
-    [RawStage]: {
-        (_: 1, x: R): unknown;
-    };
-}
-export interface RWCollection<in R extends O, out Out extends O = R> extends CommonCollection {
-    [RawStage](_: 2): Out;
-    [RawStage](_: 1, x: R): unknown;
-}
-export type OPick<V, K extends StrKey<V>, E extends StrKey<V> = never> = O & Pick<V, K | E>;
-export type OPickD<V extends Model, K extends StrKey<V>> = OPick<V, K, 'deletedAt' | '_id'>;
-export type View<V extends Model, K extends StrKey<V>> = {
-    collection: ReadonlyCollection<V | Del>;
-    projection: ExactKeys<K>;
-    match?: Expr<boolean, OPickD<V, K>>;
-    hardMatch?: Query<V>;
-};
-export {};