@derivation/rpc 0.6.0 → 0.7.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/iso.cjs +9 -0
- package/dist/iso.cjs.map +1 -1
- package/dist/iso.d.cts +6 -1
- package/dist/iso.d.ts +6 -1
- package/dist/iso.js +8 -0
- package/dist/iso.js.map +1 -1
- package/package.json +5 -10
package/dist/iso.cjs
CHANGED
|
@@ -21,6 +21,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
|
|
|
21
21
|
var iso_exports = {};
|
|
22
22
|
__export(iso_exports, {
|
|
23
23
|
array: () => array,
|
|
24
|
+
cellIso: () => cellIso,
|
|
24
25
|
compose: () => compose,
|
|
25
26
|
flip: () => flip,
|
|
26
27
|
id: () => id,
|
|
@@ -38,6 +39,7 @@ __export(iso_exports, {
|
|
|
38
39
|
module.exports = __toCommonJS(iso_exports);
|
|
39
40
|
var import_immutable = require("immutable");
|
|
40
41
|
var import_immutable2 = require("immutable");
|
|
42
|
+
var import_composable = require("@derivation/composable");
|
|
41
43
|
function id() {
|
|
42
44
|
return {
|
|
43
45
|
to: (x) => x,
|
|
@@ -131,9 +133,16 @@ function immutableMap(keyIso, valueIso) {
|
|
|
131
133
|
}
|
|
132
134
|
};
|
|
133
135
|
}
|
|
136
|
+
function cellIso(valueIso) {
|
|
137
|
+
return {
|
|
138
|
+
to: (cell) => valueIso.to(cell.value),
|
|
139
|
+
from: (value) => new import_composable.Cell(valueIso.from(value))
|
|
140
|
+
};
|
|
141
|
+
}
|
|
134
142
|
// Annotate the CommonJS export names for ESM import in node:
|
|
135
143
|
0 && (module.exports = {
|
|
136
144
|
array,
|
|
145
|
+
cellIso,
|
|
137
146
|
compose,
|
|
138
147
|
flip,
|
|
139
148
|
id,
|
package/dist/iso.cjs.map
CHANGED
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"sources":["../src/iso.ts"],"sourcesContent":["import { Record as ImmutableRecord, RecordOf } from \"immutable\";\nimport { List, Set as ImmutableSet, Map as ImmutableMap } from \"immutable\";\n\nexport interface Iso<In, Out> {\n to(x: In): Out;\n from(x: Out): In;\n}\n\nexport function id<A>(): Iso<A, A> {\n return {\n to: (x: A) => x,\n from: (x: A) => x,\n };\n}\n\nexport function unknown<A>(): Iso<A, unknown> {\n return {\n to: (x: A) => x,\n from: (x: unknown) => x as A,\n };\n}\n\nexport function flip<A, B>(iso: Iso<A, B>): Iso<B, A> {\n return {\n to: (x: B) => iso.from(x),\n from: (x: A) => iso.to(x),\n };\n}\n\nexport function compose<A, B, C>(\n first: Iso<A, B>,\n second: Iso<B, C>,\n): Iso<A, C> {\n return {\n to: (x: A) => second.to(first.to(x)),\n from: (x: C) => first.from(second.from(x)),\n };\n}\n\nexport function array<A, B>(itemIso: Iso<A, B>): Iso<Array<A>, Array<B>> {\n return {\n to: (xs: Array<A>) => xs.map(itemIso.to),\n from: (xs: Array<B>) => xs.map(itemIso.from),\n };\n}\n\n\nexport type IsoIn<T> = T extends Iso<infer A, unknown> ? A : never;\nexport type IsoOut<T> = T extends Iso<unknown, infer B> ? B : never;\n\ntype ObjectIsos = Record<string, Iso<unknown, unknown>>;\ntype ObjectIn<T extends ObjectIsos> = { [K in keyof T]: IsoIn<T[K]> };\ntype ObjectOut<T extends ObjectIsos> = { [K in keyof T]: IsoOut<T[K]> };\n\nexport function object<T extends ObjectIsos>(\n spec: T,\n): Iso<ObjectIn<T>, ObjectOut<T>> {\n return {\n to: (x) => {\n const result = {} as ObjectOut<T>;\n for (const key in spec) {\n result[key] = spec[key].to(x[key]) as IsoOut<\n T[Extract<keyof T, string>]\n >;\n }\n return result;\n },\n from: (x) => {\n const result = {} as ObjectIn<T>;\n for (const key in spec) {\n result[key] = spec[key].from(x[key]) as IsoIn<\n T[Extract<keyof T, string>]\n >;\n }\n return result;\n },\n };\n}\n\nexport function shallowRecord<T extends Record<string, unknown>>(): Iso<\n RecordOf<T>,\n T\n> {\n return {\n to: (x: RecordOf<T>): T => x.toObject(),\n from: (x: T): RecordOf<T> => ImmutableRecord<T>(x)(x),\n };\n}\n\nexport function record<T extends ObjectIsos>(\n spec: T,\n): Iso<RecordOf<ObjectIn<T>>, ObjectOut<T>> {\n return compose(shallowRecord(), object(spec));\n}\n\ntype TupleIsos = Array<Iso<unknown, unknown>>;\ntype TupleIn<T extends TupleIsos> = { [K in keyof T]: IsoIn<T[K]> };\ntype TupleOut<T extends TupleIsos> = { [K in keyof T]: IsoOut<T[K]> };\n\nexport function tuple<T extends TupleIsos>(\n ...isos: T\n): Iso<TupleIn<T>, TupleOut<T>> {\n return {\n to: (x) => x.map((xi, i) => isos[i].to(xi)) as TupleOut<T>,\n from: (x) => x.map((xi, i) => isos[i].from(xi)) as TupleIn<T>,\n };\n}\n\nexport function map<K, V, K2, V2>(\n keyIso: Iso<K, K2>,\n valueIso: Iso<V, V2>,\n): Iso<Map<K, V>, Array<[K2, V2]>> {\n return {\n to: (m) => [...m.entries()].map(([k, v]) => [keyIso.to(k), valueIso.to(v)]),\n from: (entries) =>\n new Map(entries.map(([k, v]) => [keyIso.from(k), valueIso.from(v)])),\n };\n}\n\n\n/**\n * A shallow isomorphism between an Immutable.js List and a standard Array.\n */\nexport function shallowList<A>(): Iso<List<A>, Array<A>> {\n return {\n to: (x: List<A>): Array<A> => x.toArray(),\n from: (x: Array<A>): List<A> => List(x),\n };\n}\n\n/**\n * A deep isomorphism that converts a List to an Array and\n * applies an itemIso to every element.\n */\nexport function list<A, B>(itemIso: Iso<A, B>): Iso<List<A>, Array<B>> {\n return compose(shallowList<A>(), array(itemIso));\n}\n\n/**\n * Deep conversion: ImmutableSet<A> <-> Array<B>\n * Note: Converting to Array is usually safer for serialization than native Set.\n */\nexport function immutableSet<A, B>(\n itemIso: Iso<A, B>,\n): Iso<ImmutableSet<A>, Array<B>> {\n return {\n to: (xs: ImmutableSet<A>) => xs.toArray().map(itemIso.to),\n from: (xs: Array<B>) => ImmutableSet(xs.map(itemIso.from)),\n };\n}\n\n/**\n * Deep conversion: ImmutableMap<K, V> <-> Array<[K2, V2]>\n */\nexport function immutableMap<K, V, K2, V2>(\n keyIso: Iso<K, K2>,\n valueIso: Iso<V, V2>,\n): Iso<ImmutableMap<K, V>, Array<[K2, V2]>> {\n const entryIso = tuple(keyIso, valueIso);\n return {\n to: (m) =>\n m\n .entrySeq()\n .toArray()\n .map((e) => entryIso.to([...e] as [K, V])),\n from: (entries) => {\n return ImmutableMap(entries.map((e) => entryIso.from(e)));\n },\n };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,uBAAoD;AACpD,IAAAA,oBAA+D;
|
|
1
|
+
{"version":3,"sources":["../src/iso.ts"],"sourcesContent":["import { Record as ImmutableRecord, RecordOf } from \"immutable\";\nimport { List, Set as ImmutableSet, Map as ImmutableMap } from \"immutable\";\nimport { Cell } from \"@derivation/composable\";\n\nexport interface Iso<In, Out> {\n to(x: In): Out;\n from(x: Out): In;\n}\n\nexport function id<A>(): Iso<A, A> {\n return {\n to: (x: A) => x,\n from: (x: A) => x,\n };\n}\n\nexport function unknown<A>(): Iso<A, unknown> {\n return {\n to: (x: A) => x,\n from: (x: unknown) => x as A,\n };\n}\n\nexport function flip<A, B>(iso: Iso<A, B>): Iso<B, A> {\n return {\n to: (x: B) => iso.from(x),\n from: (x: A) => iso.to(x),\n };\n}\n\nexport function compose<A, B, C>(\n first: Iso<A, B>,\n second: Iso<B, C>,\n): Iso<A, C> {\n return {\n to: (x: A) => second.to(first.to(x)),\n from: (x: C) => first.from(second.from(x)),\n };\n}\n\nexport function array<A, B>(itemIso: Iso<A, B>): Iso<Array<A>, Array<B>> {\n return {\n to: (xs: Array<A>) => xs.map(itemIso.to),\n from: (xs: Array<B>) => xs.map(itemIso.from),\n };\n}\n\n\nexport type IsoIn<T> = T extends Iso<infer A, unknown> ? A : never;\nexport type IsoOut<T> = T extends Iso<unknown, infer B> ? B : never;\n\ntype ObjectIsos = Record<string, Iso<unknown, unknown>>;\ntype ObjectIn<T extends ObjectIsos> = { [K in keyof T]: IsoIn<T[K]> };\ntype ObjectOut<T extends ObjectIsos> = { [K in keyof T]: IsoOut<T[K]> };\n\nexport function object<T extends ObjectIsos>(\n spec: T,\n): Iso<ObjectIn<T>, ObjectOut<T>> {\n return {\n to: (x) => {\n const result = {} as ObjectOut<T>;\n for (const key in spec) {\n result[key] = spec[key].to(x[key]) as IsoOut<\n T[Extract<keyof T, string>]\n >;\n }\n return result;\n },\n from: (x) => {\n const result = {} as ObjectIn<T>;\n for (const key in spec) {\n result[key] = spec[key].from(x[key]) as IsoIn<\n T[Extract<keyof T, string>]\n >;\n }\n return result;\n },\n };\n}\n\nexport function shallowRecord<T extends Record<string, unknown>>(): Iso<\n RecordOf<T>,\n T\n> {\n return {\n to: (x: RecordOf<T>): T => x.toObject(),\n from: (x: T): RecordOf<T> => ImmutableRecord<T>(x)(x),\n };\n}\n\nexport function record<T extends ObjectIsos>(\n spec: T,\n): Iso<RecordOf<ObjectIn<T>>, ObjectOut<T>> {\n return compose(shallowRecord(), object(spec));\n}\n\ntype TupleIsos = Array<Iso<unknown, unknown>>;\ntype TupleIn<T extends TupleIsos> = { [K in keyof T]: IsoIn<T[K]> };\ntype TupleOut<T extends TupleIsos> = { [K in keyof T]: IsoOut<T[K]> };\n\nexport function tuple<T extends TupleIsos>(\n ...isos: T\n): Iso<TupleIn<T>, TupleOut<T>> {\n return {\n to: (x) => x.map((xi, i) => isos[i].to(xi)) as TupleOut<T>,\n from: (x) => x.map((xi, i) => isos[i].from(xi)) as TupleIn<T>,\n };\n}\n\nexport function map<K, V, K2, V2>(\n keyIso: Iso<K, K2>,\n valueIso: Iso<V, V2>,\n): Iso<Map<K, V>, Array<[K2, V2]>> {\n return {\n to: (m) => [...m.entries()].map(([k, v]) => [keyIso.to(k), valueIso.to(v)]),\n from: (entries) =>\n new Map(entries.map(([k, v]) => [keyIso.from(k), valueIso.from(v)])),\n };\n}\n\n\n/**\n * A shallow isomorphism between an Immutable.js List and a standard Array.\n */\nexport function shallowList<A>(): Iso<List<A>, Array<A>> {\n return {\n to: (x: List<A>): Array<A> => x.toArray(),\n from: (x: Array<A>): List<A> => List(x),\n };\n}\n\n/**\n * A deep isomorphism that converts a List to an Array and\n * applies an itemIso to every element.\n */\nexport function list<A, B>(itemIso: Iso<A, B>): Iso<List<A>, Array<B>> {\n return compose(shallowList<A>(), array(itemIso));\n}\n\n/**\n * Deep conversion: ImmutableSet<A> <-> Array<B>\n * Note: Converting to Array is usually safer for serialization than native Set.\n */\nexport function immutableSet<A, B>(\n itemIso: Iso<A, B>,\n): Iso<ImmutableSet<A>, Array<B>> {\n return {\n to: (xs: ImmutableSet<A>) => xs.toArray().map(itemIso.to),\n from: (xs: Array<B>) => ImmutableSet(xs.map(itemIso.from)),\n };\n}\n\n/**\n * Deep conversion: ImmutableMap<K, V> <-> Array<[K2, V2]>\n */\nexport function immutableMap<K, V, K2, V2>(\n keyIso: Iso<K, K2>,\n valueIso: Iso<V, V2>,\n): Iso<ImmutableMap<K, V>, Array<[K2, V2]>> {\n const entryIso = tuple(keyIso, valueIso);\n return {\n to: (m) =>\n m\n .entrySeq()\n .toArray()\n .map((e) => entryIso.to([...e] as [K, V])),\n from: (entries) => {\n return ImmutableMap(entries.map((e) => entryIso.from(e)));\n },\n };\n}\n\n/**\n * Deep conversion: Cell<A> <-> B\n */\nexport function cellIso<A extends NonNullable<unknown>, B>(\n valueIso: Iso<A, B>,\n): Iso<Cell<A>, B> {\n return {\n to: (cell: Cell<A>) => valueIso.to(cell.value),\n from: (value: B) => new Cell(valueIso.from(value)),\n };\n}\n"],"mappings":"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","names":["import_immutable","ImmutableRecord","ImmutableSet","ImmutableMap"]}
|
package/dist/iso.d.cts
CHANGED
|
@@ -1,4 +1,5 @@
|
|
|
1
1
|
import { Map as Map$1, Set, List, RecordOf } from 'immutable';
|
|
2
|
+
import { Cell } from '@derivation/composable';
|
|
2
3
|
|
|
3
4
|
interface Iso<In, Out> {
|
|
4
5
|
to(x: In): Out;
|
|
@@ -48,5 +49,9 @@ declare function immutableSet<A, B>(itemIso: Iso<A, B>): Iso<Set<A>, Array<B>>;
|
|
|
48
49
|
* Deep conversion: ImmutableMap<K, V> <-> Array<[K2, V2]>
|
|
49
50
|
*/
|
|
50
51
|
declare function immutableMap<K, V, K2, V2>(keyIso: Iso<K, K2>, valueIso: Iso<V, V2>): Iso<Map$1<K, V>, Array<[K2, V2]>>;
|
|
52
|
+
/**
|
|
53
|
+
* Deep conversion: Cell<A> <-> B
|
|
54
|
+
*/
|
|
55
|
+
declare function cellIso<A extends NonNullable<unknown>, B>(valueIso: Iso<A, B>): Iso<Cell<A>, B>;
|
|
51
56
|
|
|
52
|
-
export { type Iso, type IsoIn, type IsoOut, array, compose, flip, id, immutableMap, immutableSet, list, map, object, record, shallowList, shallowRecord, tuple, unknown };
|
|
57
|
+
export { type Iso, type IsoIn, type IsoOut, array, cellIso, compose, flip, id, immutableMap, immutableSet, list, map, object, record, shallowList, shallowRecord, tuple, unknown };
|
package/dist/iso.d.ts
CHANGED
|
@@ -1,4 +1,5 @@
|
|
|
1
1
|
import { Map as Map$1, Set, List, RecordOf } from 'immutable';
|
|
2
|
+
import { Cell } from '@derivation/composable';
|
|
2
3
|
|
|
3
4
|
interface Iso<In, Out> {
|
|
4
5
|
to(x: In): Out;
|
|
@@ -48,5 +49,9 @@ declare function immutableSet<A, B>(itemIso: Iso<A, B>): Iso<Set<A>, Array<B>>;
|
|
|
48
49
|
* Deep conversion: ImmutableMap<K, V> <-> Array<[K2, V2]>
|
|
49
50
|
*/
|
|
50
51
|
declare function immutableMap<K, V, K2, V2>(keyIso: Iso<K, K2>, valueIso: Iso<V, V2>): Iso<Map$1<K, V>, Array<[K2, V2]>>;
|
|
52
|
+
/**
|
|
53
|
+
* Deep conversion: Cell<A> <-> B
|
|
54
|
+
*/
|
|
55
|
+
declare function cellIso<A extends NonNullable<unknown>, B>(valueIso: Iso<A, B>): Iso<Cell<A>, B>;
|
|
51
56
|
|
|
52
|
-
export { type Iso, type IsoIn, type IsoOut, array, compose, flip, id, immutableMap, immutableSet, list, map, object, record, shallowList, shallowRecord, tuple, unknown };
|
|
57
|
+
export { type Iso, type IsoIn, type IsoOut, array, cellIso, compose, flip, id, immutableMap, immutableSet, list, map, object, record, shallowList, shallowRecord, tuple, unknown };
|
package/dist/iso.js
CHANGED
|
@@ -1,6 +1,7 @@
|
|
|
1
1
|
// src/iso.ts
|
|
2
2
|
import { Record as ImmutableRecord } from "immutable";
|
|
3
3
|
import { List, Set as ImmutableSet, Map as ImmutableMap } from "immutable";
|
|
4
|
+
import { Cell } from "@derivation/composable";
|
|
4
5
|
function id() {
|
|
5
6
|
return {
|
|
6
7
|
to: (x) => x,
|
|
@@ -94,8 +95,15 @@ function immutableMap(keyIso, valueIso) {
|
|
|
94
95
|
}
|
|
95
96
|
};
|
|
96
97
|
}
|
|
98
|
+
function cellIso(valueIso) {
|
|
99
|
+
return {
|
|
100
|
+
to: (cell) => valueIso.to(cell.value),
|
|
101
|
+
from: (value) => new Cell(valueIso.from(value))
|
|
102
|
+
};
|
|
103
|
+
}
|
|
97
104
|
export {
|
|
98
105
|
array,
|
|
106
|
+
cellIso,
|
|
99
107
|
compose,
|
|
100
108
|
flip,
|
|
101
109
|
id,
|
package/dist/iso.js.map
CHANGED
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"sources":["../src/iso.ts"],"sourcesContent":["import { Record as ImmutableRecord, RecordOf } from \"immutable\";\nimport { List, Set as ImmutableSet, Map as ImmutableMap } from \"immutable\";\n\nexport interface Iso<In, Out> {\n to(x: In): Out;\n from(x: Out): In;\n}\n\nexport function id<A>(): Iso<A, A> {\n return {\n to: (x: A) => x,\n from: (x: A) => x,\n };\n}\n\nexport function unknown<A>(): Iso<A, unknown> {\n return {\n to: (x: A) => x,\n from: (x: unknown) => x as A,\n };\n}\n\nexport function flip<A, B>(iso: Iso<A, B>): Iso<B, A> {\n return {\n to: (x: B) => iso.from(x),\n from: (x: A) => iso.to(x),\n };\n}\n\nexport function compose<A, B, C>(\n first: Iso<A, B>,\n second: Iso<B, C>,\n): Iso<A, C> {\n return {\n to: (x: A) => second.to(first.to(x)),\n from: (x: C) => first.from(second.from(x)),\n };\n}\n\nexport function array<A, B>(itemIso: Iso<A, B>): Iso<Array<A>, Array<B>> {\n return {\n to: (xs: Array<A>) => xs.map(itemIso.to),\n from: (xs: Array<B>) => xs.map(itemIso.from),\n };\n}\n\n\nexport type IsoIn<T> = T extends Iso<infer A, unknown> ? A : never;\nexport type IsoOut<T> = T extends Iso<unknown, infer B> ? B : never;\n\ntype ObjectIsos = Record<string, Iso<unknown, unknown>>;\ntype ObjectIn<T extends ObjectIsos> = { [K in keyof T]: IsoIn<T[K]> };\ntype ObjectOut<T extends ObjectIsos> = { [K in keyof T]: IsoOut<T[K]> };\n\nexport function object<T extends ObjectIsos>(\n spec: T,\n): Iso<ObjectIn<T>, ObjectOut<T>> {\n return {\n to: (x) => {\n const result = {} as ObjectOut<T>;\n for (const key in spec) {\n result[key] = spec[key].to(x[key]) as IsoOut<\n T[Extract<keyof T, string>]\n >;\n }\n return result;\n },\n from: (x) => {\n const result = {} as ObjectIn<T>;\n for (const key in spec) {\n result[key] = spec[key].from(x[key]) as IsoIn<\n T[Extract<keyof T, string>]\n >;\n }\n return result;\n },\n };\n}\n\nexport function shallowRecord<T extends Record<string, unknown>>(): Iso<\n RecordOf<T>,\n T\n> {\n return {\n to: (x: RecordOf<T>): T => x.toObject(),\n from: (x: T): RecordOf<T> => ImmutableRecord<T>(x)(x),\n };\n}\n\nexport function record<T extends ObjectIsos>(\n spec: T,\n): Iso<RecordOf<ObjectIn<T>>, ObjectOut<T>> {\n return compose(shallowRecord(), object(spec));\n}\n\ntype TupleIsos = Array<Iso<unknown, unknown>>;\ntype TupleIn<T extends TupleIsos> = { [K in keyof T]: IsoIn<T[K]> };\ntype TupleOut<T extends TupleIsos> = { [K in keyof T]: IsoOut<T[K]> };\n\nexport function tuple<T extends TupleIsos>(\n ...isos: T\n): Iso<TupleIn<T>, TupleOut<T>> {\n return {\n to: (x) => x.map((xi, i) => isos[i].to(xi)) as TupleOut<T>,\n from: (x) => x.map((xi, i) => isos[i].from(xi)) as TupleIn<T>,\n };\n}\n\nexport function map<K, V, K2, V2>(\n keyIso: Iso<K, K2>,\n valueIso: Iso<V, V2>,\n): Iso<Map<K, V>, Array<[K2, V2]>> {\n return {\n to: (m) => [...m.entries()].map(([k, v]) => [keyIso.to(k), valueIso.to(v)]),\n from: (entries) =>\n new Map(entries.map(([k, v]) => [keyIso.from(k), valueIso.from(v)])),\n };\n}\n\n\n/**\n * A shallow isomorphism between an Immutable.js List and a standard Array.\n */\nexport function shallowList<A>(): Iso<List<A>, Array<A>> {\n return {\n to: (x: List<A>): Array<A> => x.toArray(),\n from: (x: Array<A>): List<A> => List(x),\n };\n}\n\n/**\n * A deep isomorphism that converts a List to an Array and\n * applies an itemIso to every element.\n */\nexport function list<A, B>(itemIso: Iso<A, B>): Iso<List<A>, Array<B>> {\n return compose(shallowList<A>(), array(itemIso));\n}\n\n/**\n * Deep conversion: ImmutableSet<A> <-> Array<B>\n * Note: Converting to Array is usually safer for serialization than native Set.\n */\nexport function immutableSet<A, B>(\n itemIso: Iso<A, B>,\n): Iso<ImmutableSet<A>, Array<B>> {\n return {\n to: (xs: ImmutableSet<A>) => xs.toArray().map(itemIso.to),\n from: (xs: Array<B>) => ImmutableSet(xs.map(itemIso.from)),\n };\n}\n\n/**\n * Deep conversion: ImmutableMap<K, V> <-> Array<[K2, V2]>\n */\nexport function immutableMap<K, V, K2, V2>(\n keyIso: Iso<K, K2>,\n valueIso: Iso<V, V2>,\n): Iso<ImmutableMap<K, V>, Array<[K2, V2]>> {\n const entryIso = tuple(keyIso, valueIso);\n return {\n to: (m) =>\n m\n .entrySeq()\n .toArray()\n .map((e) => entryIso.to([...e] as [K, V])),\n from: (entries) => {\n return ImmutableMap(entries.map((e) => entryIso.from(e)));\n },\n };\n}\n"],"mappings":";AAAA,SAAS,UAAU,uBAAiC;AACpD,SAAS,MAAM,OAAO,cAAc,OAAO,oBAAoB;
|
|
1
|
+
{"version":3,"sources":["../src/iso.ts"],"sourcesContent":["import { Record as ImmutableRecord, RecordOf } from \"immutable\";\nimport { List, Set as ImmutableSet, Map as ImmutableMap } from \"immutable\";\nimport { Cell } from \"@derivation/composable\";\n\nexport interface Iso<In, Out> {\n to(x: In): Out;\n from(x: Out): In;\n}\n\nexport function id<A>(): Iso<A, A> {\n return {\n to: (x: A) => x,\n from: (x: A) => x,\n };\n}\n\nexport function unknown<A>(): Iso<A, unknown> {\n return {\n to: (x: A) => x,\n from: (x: unknown) => x as A,\n };\n}\n\nexport function flip<A, B>(iso: Iso<A, B>): Iso<B, A> {\n return {\n to: (x: B) => iso.from(x),\n from: (x: A) => iso.to(x),\n };\n}\n\nexport function compose<A, B, C>(\n first: Iso<A, B>,\n second: Iso<B, C>,\n): Iso<A, C> {\n return {\n to: (x: A) => second.to(first.to(x)),\n from: (x: C) => first.from(second.from(x)),\n };\n}\n\nexport function array<A, B>(itemIso: Iso<A, B>): Iso<Array<A>, Array<B>> {\n return {\n to: (xs: Array<A>) => xs.map(itemIso.to),\n from: (xs: Array<B>) => xs.map(itemIso.from),\n };\n}\n\n\nexport type IsoIn<T> = T extends Iso<infer A, unknown> ? A : never;\nexport type IsoOut<T> = T extends Iso<unknown, infer B> ? B : never;\n\ntype ObjectIsos = Record<string, Iso<unknown, unknown>>;\ntype ObjectIn<T extends ObjectIsos> = { [K in keyof T]: IsoIn<T[K]> };\ntype ObjectOut<T extends ObjectIsos> = { [K in keyof T]: IsoOut<T[K]> };\n\nexport function object<T extends ObjectIsos>(\n spec: T,\n): Iso<ObjectIn<T>, ObjectOut<T>> {\n return {\n to: (x) => {\n const result = {} as ObjectOut<T>;\n for (const key in spec) {\n result[key] = spec[key].to(x[key]) as IsoOut<\n T[Extract<keyof T, string>]\n >;\n }\n return result;\n },\n from: (x) => {\n const result = {} as ObjectIn<T>;\n for (const key in spec) {\n result[key] = spec[key].from(x[key]) as IsoIn<\n T[Extract<keyof T, string>]\n >;\n }\n return result;\n },\n };\n}\n\nexport function shallowRecord<T extends Record<string, unknown>>(): Iso<\n RecordOf<T>,\n T\n> {\n return {\n to: (x: RecordOf<T>): T => x.toObject(),\n from: (x: T): RecordOf<T> => ImmutableRecord<T>(x)(x),\n };\n}\n\nexport function record<T extends ObjectIsos>(\n spec: T,\n): Iso<RecordOf<ObjectIn<T>>, ObjectOut<T>> {\n return compose(shallowRecord(), object(spec));\n}\n\ntype TupleIsos = Array<Iso<unknown, unknown>>;\ntype TupleIn<T extends TupleIsos> = { [K in keyof T]: IsoIn<T[K]> };\ntype TupleOut<T extends TupleIsos> = { [K in keyof T]: IsoOut<T[K]> };\n\nexport function tuple<T extends TupleIsos>(\n ...isos: T\n): Iso<TupleIn<T>, TupleOut<T>> {\n return {\n to: (x) => x.map((xi, i) => isos[i].to(xi)) as TupleOut<T>,\n from: (x) => x.map((xi, i) => isos[i].from(xi)) as TupleIn<T>,\n };\n}\n\nexport function map<K, V, K2, V2>(\n keyIso: Iso<K, K2>,\n valueIso: Iso<V, V2>,\n): Iso<Map<K, V>, Array<[K2, V2]>> {\n return {\n to: (m) => [...m.entries()].map(([k, v]) => [keyIso.to(k), valueIso.to(v)]),\n from: (entries) =>\n new Map(entries.map(([k, v]) => [keyIso.from(k), valueIso.from(v)])),\n };\n}\n\n\n/**\n * A shallow isomorphism between an Immutable.js List and a standard Array.\n */\nexport function shallowList<A>(): Iso<List<A>, Array<A>> {\n return {\n to: (x: List<A>): Array<A> => x.toArray(),\n from: (x: Array<A>): List<A> => List(x),\n };\n}\n\n/**\n * A deep isomorphism that converts a List to an Array and\n * applies an itemIso to every element.\n */\nexport function list<A, B>(itemIso: Iso<A, B>): Iso<List<A>, Array<B>> {\n return compose(shallowList<A>(), array(itemIso));\n}\n\n/**\n * Deep conversion: ImmutableSet<A> <-> Array<B>\n * Note: Converting to Array is usually safer for serialization than native Set.\n */\nexport function immutableSet<A, B>(\n itemIso: Iso<A, B>,\n): Iso<ImmutableSet<A>, Array<B>> {\n return {\n to: (xs: ImmutableSet<A>) => xs.toArray().map(itemIso.to),\n from: (xs: Array<B>) => ImmutableSet(xs.map(itemIso.from)),\n };\n}\n\n/**\n * Deep conversion: ImmutableMap<K, V> <-> Array<[K2, V2]>\n */\nexport function immutableMap<K, V, K2, V2>(\n keyIso: Iso<K, K2>,\n valueIso: Iso<V, V2>,\n): Iso<ImmutableMap<K, V>, Array<[K2, V2]>> {\n const entryIso = tuple(keyIso, valueIso);\n return {\n to: (m) =>\n m\n .entrySeq()\n .toArray()\n .map((e) => entryIso.to([...e] as [K, V])),\n from: (entries) => {\n return ImmutableMap(entries.map((e) => entryIso.from(e)));\n },\n };\n}\n\n/**\n * Deep conversion: Cell<A> <-> B\n */\nexport function cellIso<A extends NonNullable<unknown>, B>(\n valueIso: Iso<A, B>,\n): Iso<Cell<A>, B> {\n return {\n to: (cell: Cell<A>) => valueIso.to(cell.value),\n from: (value: B) => new Cell(valueIso.from(value)),\n };\n}\n"],"mappings":"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","names":[]}
|
package/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "@derivation/rpc",
|
|
3
|
-
"version": "0.
|
|
3
|
+
"version": "0.7.0",
|
|
4
4
|
"homepage": "https://github.com/derivationjs/rpc",
|
|
5
5
|
"repository": {
|
|
6
6
|
"type": "git",
|
|
@@ -48,24 +48,19 @@
|
|
|
48
48
|
"build": "tsup",
|
|
49
49
|
"test": "vitest run",
|
|
50
50
|
"test:watch": "vitest",
|
|
51
|
-
"lint": "eslint src",
|
|
52
51
|
"typecheck": "tsc --noEmit",
|
|
53
|
-
"prepack": "rm -rf dist && npm run
|
|
52
|
+
"prepack": "rm -rf dist && npm run typecheck && npm run test"
|
|
54
53
|
},
|
|
55
54
|
"dependencies": {
|
|
56
|
-
"@derivation/composable": "^0.
|
|
57
|
-
"@types/node": "^25.
|
|
55
|
+
"@derivation/composable": "^0.7.0",
|
|
56
|
+
"@types/node": "^25.3.3",
|
|
58
57
|
"@types/ws": "^8.18.1",
|
|
59
|
-
"derivation": "^0.
|
|
58
|
+
"derivation": "^0.7.0",
|
|
60
59
|
"immutable": "^5.1.4",
|
|
61
60
|
"ws": "^8.19.0",
|
|
62
61
|
"zod": "^4.3.6"
|
|
63
62
|
},
|
|
64
63
|
"devDependencies": {
|
|
65
|
-
"@typescript-eslint/eslint-plugin": "^8.55.0",
|
|
66
|
-
"@typescript-eslint/parser": "^8.55.0",
|
|
67
|
-
"eslint": "^9.0.0",
|
|
68
|
-
"eslint-plugin-import": "^2.32.0",
|
|
69
64
|
"tsup": "^8.5.1",
|
|
70
65
|
"typescript": "^5.9.3",
|
|
71
66
|
"vitest": "^4.0.18"
|