@omegup/msync 0.1.47 → 0.1.49

package/index.d.ts

@@ -26,6 +26,9 @@ type O<T = unknown> = Obj & T;
 type RORec<K extends keyof never, T = unknown> = {
     readonly [P in K]: T;
 };
+type PRRec<K extends keyof never, T = unknown> = {
+    [P in K]?: T;
+};
 type Rec<K extends string, T = unknown> = O<RORec<K, T>>;
 type O2 = readonly [O, O];
 type O3 = readonly [O, O, O];
@@ -39,6 +42,7 @@ interface RawObj {
 type raw = readonly rawItem[] | RawObj;
 type StrKey<T> = string & keyof T;
 type Replace<R, V> = Omit<R, StrKey<V>> & V & O;
+type ReplaceQ<R extends Q, VV, Q extends O> = Omit<R, StrKey<VV>> & Omit<VV, StrKey<Q>> & Q;
 type AsLiteral<T extends keyof any | boolean | N, V = NoUnion<T>> = T extends keyof any ? {} extends {
     [K in T]: 1;
 } ? never : V : V;
@@ -206,10 +210,10 @@ type BoolExpr<in D1, in D2, in Ctx = unknown> = {
 
 type ExactPart<T, F extends HKT<T[StrKey<T>]>> = MapOPart<T, MappedHKT<T, F>>;
 type ExactKeys<K extends string> = Exact<RORec<K, 1>, IdHKT>;
-type MapO<T, F extends HKT<StrKey<T>>> = MapOPart<T, F> & {
-    readonly [P: string]: readonly [StrKey<T>, unknown];
+type MapO<T, F extends HKT<K>, K extends StrKey<T> = StrKey<T>> = MapOPart<T, F, K> & {
+    readonly [P: string]: readonly [K, unknown];
 };
-type MapOPart<T, F extends HKT<StrKey<T>>, K extends keyof T = StrKey<T>> = {
+type MapOPart<T, F extends HKT<K>, K extends keyof T = StrKey<T>> = {
     readonly [P in K]: readonly [P, App<F, P & string>];
 };
 type Exact<T, F extends HKT<T[StrKey<T>]>> = MapO<T, MappedHKT<T, F>>;
@@ -351,27 +355,29 @@ declare const $getField: {
     <T, K extends StrKey<T>, D, C = unknown>(expr: Expr<T, D, C>, field: K): Expr<T[K], D, C>;
     <T, K extends StrKey<T>, D, C = unknown>(expr: Expr<T | N, D, C>, field: K): Expr<T[K] | null, D, C>;
 };
-type NoRaw<T> = T extends Arr<infer U> ? NoRaw<U>[] : T extends readonly unknown[] ? {
-    [K in keyof T]: NoRaw<T[K]>;
-} : T extends O ? {
-    [K in StrKey<T>]: NoRaw<T[K]>;
-} : T;
-type RONoRaw<T> = T extends Arr<infer U> ? readonly RONoRaw<U>[] : T extends readonly unknown[] ? {
-    readonly [K in keyof T]: RONoRaw<T[K]>;
-} : T extends O ? {
-    readonly [K in StrKey<T>]: RONoRaw<T[K]>;
-} : T;
-declare const func: <T extends jsonItem, A extends readonly jsonItem[], D, C = unknown>(f: (...args: NoRaw<A>) => RONoRaw<T>, ...args: { [X in keyof A]: Expr<A[X], D, C>; }) => Expr<T, D, C>;
+type AddO<T> = T extends notObj ? T : T extends Array<infer U> ? Arr<AddO<U>> : O<T>;
+declare const func: <T extends jsonItem, A extends readonly jsonItem[], D, C = unknown>(f: (...args: A) => T, ...args: { [X in keyof A]: Expr<AddO<A[X]>, D, C>; }) => Expr<AddO<T>, D, C>;
 declare const rand: () => string;
 declare const $rand: Expr<string, unknown, unknown>;
 
+type AddOs<A extends readonly unknown[]> = {
+    [K in keyof A]: AddO<A[K]>;
+};
+type PushSides<V> = {
+    0: V[];
+    1: V[];
+};
+type PushDict<V> = PRRec<string, PushSides<V>>;
 declare const $sum: <D extends O, C = unknown>(expr: Expr<number | N, D, C>) => DeltaAccumulator<D, number, C>;
-declare const $accumulator: <D, T, Ctx, A extends readonly unknown[]>(init: () => NoRaw<T>, accumulateArgs: AppMap<ExprHKT<Part<D>, Ctx>, A>, accumulate: (a: NoRaw<T>, ...args: NoRaw<A>) => NoRaw<T>, merge: (...args: NoRaw<[T | N, T]>) => NoRaw<T>) => DeltaAccumulator<D, T, Ctx>;
-declare const $countDict: <D extends O, C = unknown>(expr: Expr<string, D, C>) => DeltaAccumulator<D, Rec<string, number>, C>;
-declare const $countDictArray: <D extends O, C = unknown>(expr: Expr<Arr<string>, D, C>) => DeltaAccumulator<D, Rec<string, number>, C>;
-declare const $pushDict: <D extends O, V, C = unknown>(key: Expr<string, D, C>, value: Expr<V, D, C>) => DeltaAccumulator<D, Rec<string, Rec<"0" | "1", Arr<V>>>, C>;
-declare const $keys: <D extends O, C = unknown>(expr: Expr<Rec<string, number>, D, C>) => Expr<Arr<string>, D, C>;
-declare const $entries: <D extends O, V, C = unknown>(expr: Expr<Rec<string, Rec<"1" | "0", Arr<V>>>, D, C>) => Expr<Arr<Rec<"k", string> & Rec<"v", V>>, D, C>;
+declare const $accumulator: <D, T, Ctx, A extends readonly unknown[]>(init: () => T, accumulateArgs: AppMap<ExprHKT<Part<D>, Ctx>, AddOs<A>>, accumulate: (a: T, ...args: A) => T, merge: (...args: [T | N, T]) => T) => DeltaAccumulator<D, AddO<T>, Ctx>;
+declare const $countDict: <D extends O, K extends string = string, C = unknown>(expr: Expr<AddO<K>, D, C>) => DeltaAccumulator<D, AddO<PRRec<K, number>>, C>;
+declare const $countDictArray: <D extends O, K extends string = string, C = unknown>(expr: Expr<AddO<K[]>, D, C>) => DeltaAccumulator<D, AddO<PRRec<K, number>>, C>;
+declare const $pushDict: <D extends O, V, C = unknown>(key: Expr<string, D, C>, value: Expr<AddO<V>, D, C>) => DeltaAccumulator<D, O<PushDict<V>>, C>;
+declare const $keys: <D extends O, K extends string = string, C = unknown>(expr: Expr<AddO<PRRec<K, number>>, D, C>) => Expr<AddO<K[]>, D, C>;
+declare const $entries: <D extends O, V, C = unknown>(expr: Expr<AddO<PushDict<V>>, D, C>) => Expr<AddO<{
+    k: string;
+    v: V;
+}[]>, D, C>;
 
 type DeltaPipe<Q extends O, T extends Q, F extends HKT<O2>, G extends HKT<O3>> = {
     with: <Q2 extends O, V extends Q2>(map: (a: Stream<Q, T, F, G>) => Stream<Q | Q2, V, F, G>) => DeltaPipe<Q | Q2, V, F, G>;
@@ -419,17 +425,17 @@ declare const $merge2: <T extends O, Out extends O = T, Ctx = unknown, In extend
 
 type GI$1<GG> = Exclude<GG, keyof TS>;
 type IdAndTsKeys = keyof (TS & ID);
-type V<VV, GG extends string> = Omit<VV, IdAndTsKeys | GI$1<GG>>;
+type V$1<VV, GG extends string> = Omit<VV, IdAndTsKeys | GI$1<GG>>;
 type Prepare<Grp, GG extends string> = TS & ID & Rec<GI$1<GG>, Grp>;
 type Par<T> = {
     [P in keyof T]?: T[P] | null;
 };
-type Loose<Grp, VV, GG extends string> = Prepare<Grp, GG> & Par<V<VV, GG>>;
-type Strict<Grp, VV, GG extends string, EE> = Prepare<Grp, GG> & V<VV, GG> & Omit<EE, IdAndTsKeys | GI$1<GG> | keyof V<VV, GG>>;
-type V_Grp<VV, GG extends string, Grp> = Rec<GI$1<GG>, Grp> & V<VV, GG>;
-type Extra<EE, VV, GG extends string> = Omit<EE, IdAndTsKeys | GI$1<GG> | keyof V<VV, GG>>;
+type Loose<Grp, VV, GG extends string> = Prepare<Grp, GG> & Par<V$1<VV, GG>>;
+type Strict<Grp, VV, GG extends string, EE> = Prepare<Grp, GG> & V$1<VV, GG> & Omit<EE, IdAndTsKeys | GI$1<GG> | keyof V$1<VV, GG>>;
+type V_Grp<VV, GG extends string, Grp> = Rec<GI$1<GG>, Grp> & V$1<VV, GG>;
+type Extra<EE, VV, GG extends string> = Omit<EE, IdAndTsKeys | GI$1<GG> | keyof V$1<VV, GG>>;
 type OrReplace<T, V> = T | Replace<T, V>;
-type MergedInput<Out, VV, Grp, GG extends string, EE> = OrReplace<Replace<Replace<Out, V<VV, GG>>, Extra<EE, VV, GG>> & Model, TS & ID & V_Grp<VV, GG, Grp> & Extra<EE, VV, GG>>;
+type MergedInput<Out, VV, Grp, GG extends string, EE> = OrReplace<Replace<Replace<Out, V$1<VV, GG>>, Extra<EE, VV, GG>> & Model, TS & ID & V_Grp<VV, GG, Grp> & Extra<EE, VV, GG>>;
 
 type Denied<GID = never> = keyof (TS & ID) | GID;
 type GI<GG> = Exclude<GG, keyof TS>;
@@ -465,14 +471,18 @@ type Updater<in R, in T, out V, in C = unknown> = {
     [Type]?(x: typeof Updater, r: R, t: T, c: C): V;
     readonly raw: <D extends O>(f: Field<D, R | N>) => readonly (readonly [string, rawItem])[];
 };
-interface UpdaterHKT<R, Old, V, C, K extends keyof Old = keyof Old, V2 extends V = V> extends HKT<StrKey<V>> {
-    readonly out: Updater<R, Get<Old, I<StrKey<V>, this>, K>, V2[I<StrKey<V>, this>], C>;
+interface UpdaterHKT<R, Old, V, C, K extends keyof Old = keyof Old, V2 extends V = V> extends UpdaterQHKT<R, Old, V2, StrKey<V>, C, K> {
+}
+interface UpdaterQHKT<R, Old, V, KV extends StrKey<V>, C, K extends keyof Old = keyof Old> extends HKT<KV> {
+    readonly out: Updater<R, Get<Old, I<KV, this>, K>, V[I<KV, this>], C>;
 }
 type Get<T, P extends string, K extends keyof T = never> = P extends K ? T[P] : P extends keyof T ? T[P] : undefined;
 declare const set: <V>() => <R, Old extends notArr, C = unknown, K extends keyof Old = never>(fields: MapO<V, UpdaterHKT<R, Old, V, C, K>>) => Updater<R, Old, O & Omit$1<Old, StrKey<V>> & V, C> & Updater<R, Arr<Old>, Arr<Omit$1<Old, StrKey<V>> & V>, C>;
 declare const to: <R, V, C = unknown, T = unknown>(expr: Expr<V, R, C>) => Updater<R, T, V, C>;
 
-declare const $set: <V extends O>() => <R extends O, C = unknown>(fields: MapO<V, UpdaterHKT<R, R, V, C>>) => DeltaStages<O, R, Replace<R, V>, C> & LinStages<O, R, Replace<R, V>, C>;
+type V<VV, Q> = Exclude<StrKey<VV>, StrKey<Q>>;
+type $Set<VV extends O, Q extends O> = <R extends Q, C = unknown>(fields: MapO<Omit<VV, StrKey<Q>>, UpdaterQHKT<R, R, VV, V<VV, Q>, C>, V<VV, Q>>) => DeltaStages<Q, R, Q & ReplaceQ<R, VV, Q>, C> & LinStages<Q, R, Q & ReplaceQ<R, VV, Q>, C>;
+declare const $set: <VV extends O, Q extends O = O>() => $Set<VV, Q>;
 declare const $replaceWith: <T extends O, V extends O>(expr: Expr<V, T>) => DeltaStages<O, T, V> & LinStages<O, T, V>;
 
 type s$1 = string;
@@ -733,4 +743,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, eqTyped, except, exprMapVal, field, fieldF, fieldM, filter, filterDefined, first, firstSure, floor, from, func, getWhenMatched, getWhenMatchedForMerge, gt, gte, inArray, isArray, ite, joinIdOf, last, log, lt, lte, makeCol, map1, mapFromPlainDateTime, mapToPlainDateTime, mapVal, matchDelta, max, maxDate, mergeExact, mergeExact0, mergeExpr, mergeObjects, minDate, monthPart, multiply, ne, nil, noop, not, notNull, now, or, padLeft, pair, prepare, rand, range, regex, root, set, setField, single, size, slice, sortArray, staging, startOf, str, sub, subtract, to, toInt, val, weekPart, wrap, year };
-export type { Accumulators, Arr, AsLiteral, Delta, DeltaAccumulator, DeltaAccumulators, DeltaStages, ExactKeys, ExprHKT, Exprs, ExprsExact, ExprsExactHKT, ExprsPart, ID, JoinId, Loose, Merge, MergeArgs, MergeInto, MergeMapOArgs, Model, MongoTypeNames, N, NoRaw, NullToOBJ, O, OPick, OPickD, Patch, RONoRaw, RORec, RawStages, Rec, Replace, SnapshotStreamExecutionResult, StrKey, Strict, TS, WriteonlyCollection, doc, jsonPrim, notArr };
+export type { Accumulators, AddO, Arr, AsLiteral, Delta, DeltaAccumulator, DeltaAccumulators, DeltaStages, ExactKeys, ExprHKT, Exprs, ExprsExact, ExprsExactHKT, ExprsPart, ID, JoinId, Loose, Merge, MergeArgs, MergeInto, MergeMapOArgs, Model, MongoTypeNames, N, NullToOBJ, O, OPick, OPickD, Patch, RORec, RawStages, Rec, Replace, SnapshotStreamExecutionResult, StrKey, Strict, TS, WriteonlyCollection, doc, jsonPrim, notArr };

package/index.esm.js

@@ -76,7 +76,8 @@ const spread = (a, b) => ({ ...a, ...mapExact(b, id$1) });
 const spread0 = (a, b) => ({ ...a, ...mapExact0(b, id$1) });
 
 const val = (val) => asExpr({
-    raw: () => asExprRaw((val && typeof val === 'object' && !(val instanceof Date)) || (typeof val === 'string' && val[0] === '$')
+    raw: () => asExprRaw((val && typeof val === 'object' && !(val instanceof Date)) ||
+        (typeof val === 'string' && val[0] === '$')
         ? { $literal: val }
         : val),
 });
@@ -864,11 +865,17 @@ const $map1 = (ex, map) => $map0({ input: ex, as: 'item', expr: map(ctx()('item'
 const $map = (ex, map) => $map1(ex, i => map(i.expr()));
 
 const subUpdater = (a, f) => ({ raw: (g) => a.raw(g.with(f)) });
+const rawSet = (fields) => (f) => {
+    return Object.entries(mapExactToObject0(fields, v => v)).flatMap(([k, v]) => v.raw(f).map(([l, v]) => [`.${k}${l}`, v]));
+};
 const set = () => (fields) => ({
-    raw: f => {
-        return Object.entries(mapExactToObject0(fields, v => v)).flatMap(([k, v]) => v.raw(f).map(([l, v]) => [`.${k}${l}`, v]));
-    },
+    raw: rawSet(fields),
 });
+const setQ = () => {
+    return (fields) => ({
+        raw: rawSet(fields),
+    });
+};
 const weaken = (updater) => ({ raw: f => updater.raw(f) });
 const to = (expr) => ({
     raw: f => [['', expr.raw(f).get()]],
@@ -1711,9 +1718,7 @@ const $setCore = (updater) => ({
     raw: $set1(updater),
     lin: $set_(updater),
 });
-const $set = () => (fields) => {
-    return $setCore(set()(fields));
-};
+const $set = () => (fields) => $setCore(setQ()(fields));
 const $replaceWith = (expr) => ({
     delta: $replaceWithDelta(expr),
     raw: $replaceWith1(expr),

package/index.js

@@ -78,7 +78,8 @@ const spread = (a, b) => ({ ...a, ...mapExact(b, id$1) });
 const spread0 = (a, b) => ({ ...a, ...mapExact0(b, id$1) });
 
 const val = (val) => asExpr({
-    raw: () => asExprRaw((val && typeof val === 'object' && !(val instanceof Date)) || (typeof val === 'string' && val[0] === '$')
+    raw: () => asExprRaw((val && typeof val === 'object' && !(val instanceof Date)) ||
+        (typeof val === 'string' && val[0] === '$')
         ? { $literal: val }
         : val),
 });
@@ -866,11 +867,17 @@ const $map1 = (ex, map) => $map0({ input: ex, as: 'item', expr: map(ctx()('item'
 const $map = (ex, map) => $map1(ex, i => map(i.expr()));
 
 const subUpdater = (a, f) => ({ raw: (g) => a.raw(g.with(f)) });
+const rawSet = (fields) => (f) => {
+    return Object.entries(mapExactToObject0(fields, v => v)).flatMap(([k, v]) => v.raw(f).map(([l, v]) => [`.${k}${l}`, v]));
+};
 const set = () => (fields) => ({
-    raw: f => {
-        return Object.entries(mapExactToObject0(fields, v => v)).flatMap(([k, v]) => v.raw(f).map(([l, v]) => [`.${k}${l}`, v]));
-    },
+    raw: rawSet(fields),
 });
+const setQ = () => {
+    return (fields) => ({
+        raw: rawSet(fields),
+    });
+};
 const weaken = (updater) => ({ raw: f => updater.raw(f) });
 const to = (expr) => ({
     raw: f => [['', expr.raw(f).get()]],
@@ -1713,9 +1720,7 @@ const $setCore = (updater) => ({
     raw: $set1(updater),
     lin: $set_(updater),
 });
-const $set = () => (fields) => {
-    return $setCore(set()(fields));
-};
+const $set = () => (fields) => $setCore(setQ()(fields));
 const $replaceWith = (expr) => ({
     delta: $replaceWithDelta(expr),
     raw: $replaceWith1(expr),

package/package.json

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