@omegup/msync 0.1.67 → 0.1.68

package/lib/expression/array.d.ts

@@ -1,4 +1,4 @@
-import type { App, Arr, HKT, N, O, RORec, notArr } from '../../types';
+import type { App, Arr, HKT, KVEntry, N, O, RORec, notArr } from '../../types';
 import type { Expr } from '../types';
 export declare const size: <T, D, C>(expr: Expr<Arr<T>, D, C>) => Expr<number, D, C>;
 export declare const filterDefined: <T, D, C = unknown>(expr: Expr<Arr<T | N>, D, C>) => Expr<Arr<T>, D, C>;
@@ -17,11 +17,13 @@ export declare const isArray: <T extends notArr, D, C, F extends HKT<T | Arr<T>>
 export declare const inArray: <T, D, C>(item: Expr<T, D, C>, expr: Expr<Arr<T>, D, C>) => Expr<boolean, D, C>;
 export declare const array: <T, D, C = unknown>(...exprs: Expr<T, D, C>[]) => Expr<Arr<T>, D, C>;
 export declare const concatArray: <T, D, C>(...exprs: Expr<Arr<T>, D, C>[]) => Expr<Arr<T>, D, C>;
+export declare const $setUnion: <T, D, C>(...exprs: Expr<Arr<T>, D, C>[]) => Expr<Arr<T>, D, C>;
 export declare const first: <T, D, C>(expr: Expr<Arr<T>, D, C>) => Expr<T | null, D, C>;
 export declare const firstSure: <T, D, C>(expr: Expr<Arr<T>, D, C>) => Expr<T, D, C>;
 export declare const last: <T, D, C>(expr: Expr<Arr<T>, D, C>) => Expr<T | null, D, C>;
 export type NullToOBJ<N extends null> = N extends null ? O : N;
 export declare const mergeObjects: <T1, T2, D, C = unknown, N extends null = never>(...exprs: readonly [Expr<T1 | N, D, C>, ...[...Expr<T1 | T2 | N, D, C>[], Expr<T2, D, C>]]) => Expr<(T1 | NullToOBJ<N>) & T2, D, C>;
+export declare const $objectToArray: <T extends O, D, C>(expr: Expr<T, D, C>) => Expr<Arr<KVEntry<T>>, D, C>;
 export declare const anyElementTrue: <D, C = unknown>(expr: Expr<Arr<boolean>, D, C>) => Expr<boolean, D, C>;
 type Reduce<T, V> = RORec<'value', V> & RORec<'this', T>;
 export declare const $reduce: <T, V, D, C>(input: Expr<Arr<T>, D, C>, initialValue: Expr<V, D, C>, inExpr: Expr<V, D, C & Reduce<T, V>>) => Expr<V, D, C>;

package/lib/expression/val.d.ts

@@ -4,6 +4,8 @@ import type { Expr } from '../types';
 import type { ExprsExact } from './concat';
 export declare const val: <T extends rawItem>(val: T) => Expr<T, unknown>;
 export declare const current: Expr<Timestamp, unknown>;
+export declare const $rand: Expr<number, unknown>;
+export declare const rand: Expr<string, unknown, unknown>;
 export declare const $let: <T, D, C, V extends object>(vars: ExprsExact<V, D, C>, inExpr: Expr<T, D, C & V>) => Expr<T, D, C>;
 export declare const nil: Expr<null, unknown>;
 export declare const $getField: {
@@ -14,5 +16,3 @@ export type AddO<T> = T extends notObj ? T : T extends Array<infer U> ? Arr<AddO
     [K in keyof T]: AddO<T[K]>;
 }>;
 export 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>;
-export declare const rand: () => string;
-export declare const $rand: Expr<string, unknown, unknown>;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@omegup/msync",
-    "version": "0.1.67",
+    "version": "0.1.68",
     "description": "Keeps derived MongoDB data in sync with the documents it comes from.",
     "repository": {
         "type": "git",

package/types/json.d.ts

@@ -61,3 +61,9 @@ export type AsLiteral<T extends keyof any | boolean | N, V = NoUnion<T>> = T ext
     [K in T]: 1;
 } ? never : V : V;
 type NoUnion<T, V = T> = T extends T ? ([V] extends [T] ? T : never) : never;
+export type KVEntry<T> = O<{
+    [K in StrKey<T>]: {
+        readonly k: K;
+        readonly v: T[K];
+    };
+}[StrKey<T>]>;