atom.io 0.23.0 → 0.23.1

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.
Files changed (4) hide show
  1. package/ephemeral/dist/index.d.ts +12 -0
  2. package/eslint-plugin/dist/index.d.ts +73 -0
  3. package/immortal/dist/index.d.ts +103 -0
  4. package/package.json +4 -1
package/ephemeral/dist/index.d.ts ADDED
@@ -0,0 +1,12 @@
1
+ import { MutableAtomFamilyToken, MutableAtomToken, RegularAtomFamilyToken, RegularAtomToken, WritableSelectorFamilyToken, WritableSelectorToken, ReadonlySelectorFamilyToken, ReadonlySelectorToken, WritableFamilyToken, WritableToken, ReadableFamilyToken, ReadableToken } from 'atom.io';
2
+ import { Transceiver } from 'atom.io/internal';
3
+ import { Json } from 'atom.io/json';
4
+
5
+ declare function findState<T extends Transceiver<any>, J extends Json.Serializable, K extends Json.Serializable, Key extends K>(token: MutableAtomFamilyToken<T, J, K>, key: Key): MutableAtomToken<T, J>;
6
+ declare function findState<T, K extends Json.Serializable, Key extends K>(token: RegularAtomFamilyToken<T, K>, key: Key): RegularAtomToken<T>;
7
+ declare function findState<T, K extends Json.Serializable, Key extends K>(token: WritableSelectorFamilyToken<T, K>, key: Key): WritableSelectorToken<T>;
8
+ declare function findState<T, K extends Json.Serializable, Key extends K>(token: ReadonlySelectorFamilyToken<T, K>, key: Key): ReadonlySelectorToken<T>;
9
+ declare function findState<T, K extends Json.Serializable, Key extends K>(token: WritableFamilyToken<T, K>, key: Key): WritableToken<T>;
10
+ declare function findState<T, K extends Json.Serializable, Key extends K>(token: ReadableFamilyToken<T, K>, key: Key): ReadableToken<T>;
11
+
12
+ export { findState };
package/eslint-plugin/dist/index.d.ts ADDED
@@ -0,0 +1,73 @@
1
+ import * as ESTree from 'estree';
2
+ import * as eslint from 'eslint';
3
+ import { Rule } from 'eslint';
4
+ import { ESLintUtils } from '@typescript-eslint/utils';
5
+
6
+ declare const explicitStateTypes: ESLintUtils.RuleModule<"noTypeArgument", [], ESLintUtils.RuleListener>;
7
+
8
+ declare const lifespan: {
9
+ meta: {
10
+ type: "problem";
11
+ docs: {
12
+ description: string;
13
+ category: string;
14
+ recommended: false;
15
+ url: string;
16
+ };
17
+ schema: {
18
+ type: "string";
19
+ enum: string[];
20
+ default: string;
21
+ }[];
22
+ };
23
+ create(context: Rule.RuleContext): {
24
+ ImportDeclaration(node: ESTree.ImportDeclaration & Rule.NodeParentExtension): void;
25
+ CallExpression(node: ESTree.CallExpression & Rule.NodeParentExtension): void;
26
+ };
27
+ };
28
+
29
+ declare const synchronousSelectorDependencies: {
30
+ meta: {
31
+ type: "problem";
32
+ docs: {
33
+ description: string;
34
+ category: string;
35
+ recommended: false;
36
+ url: string;
37
+ };
38
+ schema: never[];
39
+ };
40
+ create(context: Rule.RuleContext): {
41
+ CallExpression(node: ESTree.CallExpression & Rule.NodeParentExtension): void;
42
+ };
43
+ };
44
+
45
+ declare const index_explicitStateTypes: typeof explicitStateTypes;
46
+ declare const index_lifespan: typeof lifespan;
47
+ declare const index_synchronousSelectorDependencies: typeof synchronousSelectorDependencies;
48
+ declare namespace index {
49
+ export { index_explicitStateTypes as explicitStateTypes, index_lifespan as lifespan, index_synchronousSelectorDependencies as synchronousSelectorDependencies };
50
+ }
51
+
52
+ declare const _default: {
53
+ rules: {
54
+ "explicit-state-types": any;
55
+ "synchronous-selector-dependencies": {
56
+ meta: {
57
+ type: "problem";
58
+ docs: {
59
+ description: string;
60
+ category: string;
61
+ recommended: false;
62
+ url: string;
63
+ };
64
+ schema: never[];
65
+ };
66
+ create(context: eslint.Rule.RuleContext): {
67
+ CallExpression(node: ESTree.CallExpression & eslint.Rule.NodeParentExtension): void;
68
+ };
69
+ };
70
+ };
71
+ };
72
+
73
+ export { index as Rules, _default as default };
package/immortal/dist/index.d.ts ADDED
@@ -0,0 +1,103 @@
1
+ import { ReadableToken, StateCreation, StateDisposal, MutableAtomFamilyToken, MutableAtomToken, RegularAtomFamilyToken, RegularAtomToken, WritableSelectorFamilyToken, WritableSelectorToken, ReadonlySelectorFamilyToken, ReadonlySelectorToken, WritableFamilyToken, WritableToken, ReadableFamilyToken, Flat, MoleculeCreation, MoleculeDisposal } from 'atom.io';
2
+ import * as Internal from 'atom.io/internal';
3
+ import { Store, Subject, Transceiver } from 'atom.io/internal';
4
+ import { Json } from 'atom.io/json';
5
+ import { Join, JoinToken } from 'atom.io/data';
6
+
7
+ declare class Molecule<Key extends Json.Serializable> {
8
+ readonly store: Store;
9
+ readonly token: MoleculeToken<Key, any, any>;
10
+ readonly type = "molecule";
11
+ get key(): Key;
12
+ readonly family?: MoleculeFamilyToken<Key, any, any>;
13
+ readonly above: Molecule<any>[];
14
+ readonly below: Molecule<any>[];
15
+ readonly tokens: ReadableToken<any>[];
16
+ readonly joins: Join<any, any, any, any>[];
17
+ readonly subject: Subject<StateCreation<any> | StateDisposal<any>>;
18
+ constructor(store: Store, above: Molecule<any> | Molecule<any>[] | undefined, token: MoleculeToken<Key, any, any>);
19
+ bond<T extends Transceiver<any>, J extends Json.Serializable, K extends string>(token: MutableAtomFamilyToken<T, J, K>): MutableAtomToken<T, J>;
20
+ bond<T, K extends Key>(token: RegularAtomFamilyToken<T, K>): RegularAtomToken<T>;
21
+ bond<T, K extends Json.Serializable>(token: WritableSelectorFamilyToken<T, K>): WritableSelectorToken<T>;
22
+ bond<T, K extends Json.Serializable>(token: ReadonlySelectorFamilyToken<T, K>): ReadonlySelectorToken<T>;
23
+ bond<T, K extends Json.Serializable>(token: WritableFamilyToken<T, K>): WritableToken<T>;
24
+ bond<T, K extends Json.Serializable>(token: ReadableFamilyToken<T, K>): ReadableToken<T>;
25
+ spawn<K extends Json.Serializable>(key: K): Molecule<K>;
26
+ with(molecule: Molecule<any>): (key: string) => Molecule<any>;
27
+ detach(child: Molecule<any>): void;
28
+ claim(child: Molecule<any>): void;
29
+ clear(): void;
30
+ join(token: JoinToken<any, any, any, any>): void;
31
+ private [Symbol.dispose];
32
+ dispose: () => void;
33
+ }
34
+
35
+ type MoleculeConstructor<Key extends Json.Serializable, Struct extends {
36
+ [key: string]: any;
37
+ }, Params extends any[]> = new (context: Molecule<any>[], token: MoleculeToken<Key, Struct, Params>, ...params: Params) => Molecule<Key> & Struct;
38
+ type MoleculeFamilyToken<Key extends Json.Serializable, Struct extends {
39
+ [key: string]: any;
40
+ }, Params extends any[]> = {
41
+ key: string;
42
+ type: `molecule_family`;
43
+ __K?: Key;
44
+ __S?: Struct;
45
+ __P?: Params;
46
+ };
47
+ type MoleculeFamily<Key extends Json.Serializable, Struct extends {
48
+ [key: string]: any;
49
+ }, Params extends any[]> = Flat<MoleculeFamilyToken<Key, Struct, Params> & {
50
+ subject: Internal.Subject<MoleculeCreation<Key> | MoleculeDisposal<Key>>;
51
+ }> & MoleculeConstructor<Key, Struct, Params>;
52
+ type MoleculeToken<Key extends Json.Serializable, Struct extends {
53
+ [key: string]: any;
54
+ }, Params extends any[]> = {
55
+ key: Key;
56
+ type: `molecule`;
57
+ family?: MoleculeFamilyToken<Key, Struct, Params>;
58
+ __S?: Struct;
59
+ __P?: Params;
60
+ };
61
+ type MoleculeFamilyOptions<Key extends Json.Serializable, Struct extends {
62
+ [key: string]: any;
63
+ }, Params extends any[]> = {
64
+ key: string;
65
+ new: (store: Internal.Store) => MoleculeConstructor<Key, Struct, Params>;
66
+ };
67
+ declare function createMoleculeFamily<Key extends Json.Serializable, Struct extends {
68
+ [key: string]: any;
69
+ }, Params extends any[]>(options: MoleculeFamilyOptions<Key, Struct, Params>, store: Internal.Store): MoleculeFamilyToken<Key, Struct, Params>;
70
+ declare function moleculeFamily<Key extends Json.Serializable, Struct extends {
71
+ [key: string]: any;
72
+ }, Params extends any[]>(options: MoleculeFamilyOptions<Key, Struct, Params>): MoleculeFamilyToken<Key, Struct, Params>;
73
+ declare function makeMoleculeInStore<Key extends Json.Serializable, Struct extends {
74
+ [key: string]: any;
75
+ }, Params extends any[]>(store: Internal.Store, context: MoleculeToken<any, any, any> | MoleculeToken<any, any, any>[], family: MoleculeFamilyToken<Key, Struct, Params>, key: Key, ...params: Params): MoleculeToken<Key, Struct, Params>;
76
+ declare function makeMolecule<Key extends Json.Serializable, Struct extends {
77
+ [key: string]: any;
78
+ }, Params extends any[]>(context: MoleculeToken<any, any, any> | MoleculeToken<any, any, any>[], family: MoleculeFamilyToken<Key, Struct, Params>, key: Key, ...params: Params): MoleculeToken<Key, Struct, Params>;
79
+ declare function useMoleculeFromStore<Key extends Json.Serializable, Struct extends {
80
+ [key: string]: any;
81
+ }, Params extends any[]>(token: MoleculeToken<Key, Struct, Params>, store: Internal.Store): (Molecule<Key> & Struct) | undefined;
82
+ declare function useMolecule<Key extends Json.Serializable, Struct extends {
83
+ [key: string]: any;
84
+ }, Params extends any[]>(token: MoleculeToken<Key, Struct, Params>): (Molecule<Key> & Struct) | undefined;
85
+ declare function disposeMolecule<Key extends Json.Serializable, Struct extends {
86
+ [key: string]: any;
87
+ }, Params extends any[]>(token: MoleculeToken<Key, Struct, Params>, store: Internal.Store): void;
88
+ type MoleculeType<M extends MoleculeFamilyToken<any, any, any>> = M extends MoleculeFamilyToken<any, infer T, any> ? T : never;
89
+ declare function makeRootMolecule(key: Json.Serializable, store?: Internal.Store): MoleculeToken<Json.Serializable, {
90
+ [key: string]: unknown;
91
+ }, []>;
92
+
93
+ declare function seekState<T extends Transceiver<any>, J extends Json.Serializable, K extends Json.Serializable, Key extends K>(token: MutableAtomFamilyToken<T, J, K>, key: Key): MutableAtomToken<T, J> | undefined;
94
+ declare function seekState<T, K extends Json.Serializable, Key extends K>(token: RegularAtomFamilyToken<T, K>, key: Key): RegularAtomToken<T> | undefined;
95
+ declare function seekState<T, K extends Json.Serializable, Key extends K>(token: WritableSelectorFamilyToken<T, K>, key: Key): WritableSelectorToken<T> | undefined;
96
+ declare function seekState<T, K extends Json.Serializable, Key extends K>(token: ReadonlySelectorFamilyToken<T, K>, key: Key): ReadonlySelectorToken<T> | undefined;
97
+ declare function seekState<T, K extends Json.Serializable, Key extends K>(token: WritableFamilyToken<T, K>, key: Key): WritableToken<T> | undefined;
98
+ declare function seekState<T, K extends Json.Serializable, Key extends K>(token: ReadableFamilyToken<T, K>, key: Key): ReadableToken<T> | undefined;
99
+ declare function seekState<K extends Json.Serializable, S extends {
100
+ [key: string]: any;
101
+ }>(token: MoleculeFamilyToken<K, S, any[]>, key: K): MoleculeToken<K, S, any[]> | undefined;
102
+
103
+ export { Molecule, type MoleculeConstructor, type MoleculeFamily, type MoleculeFamilyOptions, type MoleculeFamilyToken, type MoleculeToken, type MoleculeType, createMoleculeFamily, disposeMolecule, makeMolecule, makeMoleculeInStore, makeRootMolecule, moleculeFamily, seekState, useMolecule, useMoleculeFromStore };
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "atom.io",
3
- "version": "0.23.0",
3
+ "version": "0.23.1",
4
4
  "description": "Composable and testable reactive data library.",
5
5
  "homepage": "https://atom.io.fyi",
6
6
  "sideEffects": false,
@@ -256,6 +256,9 @@
256
256
  "build:main": "tsup",
257
257
  "build:types": "tsup --dts",
258
258
  "build:data": "cd data && tsup",
259
+ "build:ephemeral": "cd ephemeral && tsup",
260
+ "build:eslint-plugin": "cd eslint-plugin && tsup",
261
+ "build:immortal": "cd immortal && tsup",
259
262
  "build:internal": "cd internal && tsup",
260
263
  "build:introspection": "cd introspection && tsup",
261
264
  "build:json": "cd json && tsup",