@omegup/msync 0.1.50 → 0.1.52

package/index.d.ts

@@ -13,10 +13,10 @@ type rawItem = jsonPrim | raw | U;
 type Undef<I extends N> = I | (I extends never ? I : notObj);
 declare const object: unique symbol;
 declare const array$1: unique symbol;
-type A = {
+type A$1 = {
     [Type]: typeof array$1;
 };
-type Arr<T, N extends number = number> = A & {
+type Arr<T, N extends number = number> = A$1 & {
     readonly [_ in N]: T;
 };
 type Obj = {
@@ -315,15 +315,51 @@ type App<F extends HKT<X>, X> = (F & {
     readonly in: (x: X) => void;
 })['out'];
 type I<Dom, F extends HKT<Dom>> = F['in'] extends (x: infer X extends Dom) => void ? X : never;
+interface ArrHKT<Dom = unknown> extends HKT<Dom> {
+    readonly out: readonly I<Dom, this>[];
+}
 interface IdHKT<Dom = unknown> extends HKT<Dom> {
     readonly out: I<Dom, this>;
 }
+interface RConstHKT<Im, Dom = Im> extends HKT<Im, HKT<Dom, Im>> {
+    readonly out: ConstHKT<I<Im, this>, Dom>;
+}
 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]>;
+interface ApplyHKT<Dom, Im> extends HKT<[Dom, HKT<Dom, Im>], Im> {
+    readonly out: ApplyF<Dom, Im, I<[Dom, HKT<Dom, Im>], this>>;
+}
+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>>>;
+}
 type AppMap<F extends HKT<Dom>, X extends readonly Dom[], Dom = unknown> = readonly App<F, Dom>[] & {
     [I in keyof X]: App<F, X[I]>;
 };
+type AppMapRW<F extends HKT<Dom>, X extends readonly Dom[], Dom = unknown> = App<F, Dom>[] & {
+    [I in keyof X]: App<F, X[I]>;
+};
+interface PromiseHKT<Dom = unknown> extends HKT<Dom> {
+    readonly out: PromiseLike<I<Dom, this>>;
+}
+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];
+}
+interface FieldHKT<K extends string> extends DeepFieldHKT<Record<K, unknown>, Record<K, unknown>, K, IdHKT<Record<K, unknown>>> {
+}
+interface RecordHKT<K extends string, Dom = unknown> extends HKT<Dom, Record<K, Dom>> {
+    readonly out: Record<K, I<Dom, this>>;
+}
+interface RecHKT<K extends string, Dom = unknown, E = unknown> extends HKT<Dom, Rec<K, Dom>> {
+    readonly out: Rec<K, I<Dom, this>> & E;
+}
+interface UBeforeHKT<Dom = unknown> extends HKT<Dom, UBefore<Dom>> {
+    readonly out: UBefore<I<Dom, this>>;
+}
+interface And<E> extends HKT {
+    readonly out: E & I<unknown, this>;
+}
 
 declare const RawStage: unique symbol;
 declare module 'mongodb' {
@@ -417,7 +453,7 @@ type Equal<Dom, T extends Dom, V extends Dom> = {
 };
 declare const sym: <Dom, T extends Dom, V extends Dom>(eq: Equal<Dom, T, V>) => Equal<Dom, V, T>;
 declare const reflex: <Dom, T extends Dom>() => Equal<Dom, T, T>;
-declare const eqExtends: <Im, T, U, F extends HKT<T, Im>, G extends HKT<T, Im>, H extends HKT<T, Im>, M extends Im>(_1: Equal<Im, App<F, T & U>, M | App<G, T & U>>, _2: Equal<Im, App<F, Exclude<T, U>>, M | App<H, Exclude<T, U>>>) => Equal<Im, App<F, T>, T | M extends U ? App<G, T> : App<H, T>>;
+declare const eqExtends: <Im, T, U, F extends HKT<T, Im>, G extends HKT<T, Im>, H extends HKT<T, Im>, M extends Im>(_1: Equal<Im, App<F, T & U>, M | App<G, T & U>>, _2: Equal<Im, App<F, Exclude<T, U>>, M | App<H, Exclude<T, U>>>) => Equal<Im, App<F, T>, M | (T extends U ? App<G, T> : App<H, T>)>;
 declare const fromEq: <Dom, T extends Dom, V extends Dom>(eq: Pick<Equal<Dom, T, V>, "forward" | "backward">) => Equal<Dom, T, V>;
 declare const literalsEqaul: <T extends keyof any | boolean | N, V extends T>(_: AsLiteral<T> & V) => Equal<T, T, V>;
 declare const omitRORec: <K extends string, E extends string, R extends string, T extends unknown>() => Equal<unknown, RORec<Exclude<K, E | R>, T>, Omit<RORec<Exclude<K, E | R>, T>, R>>;
@@ -599,7 +635,9 @@ declare const createIndex: (collection: {
 }, indexSpec: IndexSpecification, op?: CreateIndexesOptions) => Promise<void>;
 
 declare const noop: () => void;
-declare const map1: <K extends string, Im>(k: AsLiteral<K>, to: Im) => MapO<RORec<K, Im>, ConstHKT<Im>, K>;
+declare const map1: <K extends string, Im>(k: AsLiteral<K>, to: Im) => { readonly [P in K]: [P, Im]; } & {
+    readonly [_: string]: [K, Im];
+};
 
 declare const $group_: <V extends O>() => <ID, T extends O, C = unknown>(id: Expr<ID, T, C>, args: Accumulators<T, V, C>) => RawStages<O, T, Rec<"_id", ID> & V, C, 1>;
 
@@ -792,4 +830,4 @@ declare const prepare: (testName?: string) => Promise<MongoClient$1>;
 declare const makeCol: <T extends ID>(docs: readonly OptionalUnlessRequiredId<T>[], database: Db, name?: string) => Promise<Collection<T>>;
 
 export { $accumulator, $and, $countDict, $countDictArray, $entries, $eq, $exists, $expr, $getField, $group, $groupId, $groupMerge, $group_, $gt, $gtTs, $gte, $gteTs, $ifNull, $in, $insert, $insertPart, $insertX, $keys, $let, $lookup, $lt, $lte, $map, $map0, $map1, $match, $matchDelta, $merge, $merge2, $mergeId, $mergePart, $merge_, $ne, $nin, $nor, $or, $outerLookup, $pushDict, $rand, $reduce, $replaceWith, $set, $simpleInsert, $simpleMerge, $simpleMergePart, $substr, $sum, $type, $unwind, $unwindDelta, Expr, Field, Machine, Type, add, and, anyElementTrue, array, ceil, comp, concat, concatArray, createIndex, ctx, current, dateAdd, dateDiff, dateLt, datePart, dayAndMonthPart, divide, emptyDelta, enablePreAndPostImages, eq, eqExtends, eqPar, eqTyped, except, excludeIdem, exprMapVal, field, fieldF, fieldM, filter, filterDefined, first, firstSure, floor, from, fromEq, func, getWhenMatched, getWhenMatchedForMerge, gt, gte, inArray, isArray, ite, joinIdOf, last, literalsEqaul, log, lt, lte, makeCol, map, map1, mapExact, mapExact0, mapExact1, mapExactToObject, mapExactToObject0, mapExactToObject1, mapFromPlainDateTime, mapToPlainDateTime, mapVal, matchDelta, max, maxDate, mergeExact, mergeExact0, mergeExpr, mergeObjects, minDate, monthPart, multiply, ne, nil, noop, not, notExtendExcluded, notNull, now, omitExclude, omitPick, omitRORec, or, padLeft, pair, prepare, rand, range, reflex, regex, renamedFields, root, set, setField, single, size, slice, sortArray, spread, spread0, staging, startOf, str, sub, subtract, sym, to, toInt, translateOmit, val, weekPart, wrap, year };
-export type { Accumulators, AddO, Arr, AsLiteral, Delta, DeltaAccumulator, DeltaAccumulators, DeltaStages, Equal, Exact, ExactKeys, ExactPart, ExactPart1, ExprHKT, Exprs, ExprsExact, ExprsExactHKT, ExprsPart, ID, JoinId, Loose, MapK, MapKDom, MapKPart1, MapO, MapOPart, MappedHKT, Merge, MergeArgs, MergeHKT, MergeInto, MergeMapOArgs, Model, MongoTypeNames, N, NullToOBJ, O, OPick, OPickD, Patch, RORec, RawStages, Rec, Replace, SnapshotStreamExecutionResult, StrKey, Strict, TS, WithKey1, WriteonlyCollection, doc, jsonPrim, notArr };
+export type { Accumulators, AddO, And, App, AppMap, AppMapRW, ApplyHKT, Arr, ArrHKT, AsLiteral, ConstHKT, DeepFieldHKT, Delta, DeltaAccumulator, DeltaAccumulatorHKT, DeltaAccumulators, DeltaStages, Equal, Exact, ExactKeys, ExactPart, ExactPart1, ExprHKT, Exprs, ExprsExact, ExprsExactHKT, ExprsPart, FieldHKT, HKT, I, ID, IdHKT, JoinId, Loose, MapK, MapKDom, MapKPart1, MapO, MapOPart, MappedHKT, Merge, MergeArgs, MergeHKT, MergeInto, MergeMapOArgs, MergedInput, Model, MongoTypeNames, N, NullToOBJ, O, OPick, OPickD, Patch, PromiseHKT, RConstHKT, RORec, RWCollection, RawStages, Rec, RecHKT, RecordHKT, Replace, SnapshotStreamExecutionResult, StrKey, Strict, TS, UBeforeHKT, WithKey1, WriteonlyCollection, doc, jsonPrim, notArr, µ };

package/package.json

@@ -3,7 +3,7 @@
     "module": "index.esm.js",
     "typings": "index.d.ts",
     "name": "@omegup/msync",
-    "version": "0.1.50",
+    "version": "0.1.52",
     "dependencies": {
         "dayjs": "^1.11.9",
         "dotenv": "^16.3.1",