}
25 | > {
26 | override render() {
27 | return (
28 |
29 | Hello{' '}
30 |
36 | );
37 | }
38 |
39 | onInputChange: ChangeEventHandler = (event) => {
40 | this.props.act((get, set) => set(this.props.nameAtom, event.target.value));
41 | };
42 | }
43 |
44 | const WrappedComponent = classComponentWithJotai(ClassBasedComponent);
45 |
46 | describe('with console.error muted', () => {
47 | const originalError = console.error;
48 | beforeEach(() => {
49 | console.error = jest.fn();
50 | });
51 |
52 | afterEach(() => {
53 | console.error = originalError;
54 | });
55 |
56 | it('requires World provider', () => {
57 | // Error.
58 | expect(() => render(
66 |
68 | );
69 | });
70 | });
71 |
72 | it('rerenders when atom changes', async () => {
73 | const world = World.syncWorld();
74 | render(
75 |
76 |
78 | );
79 | expect(Array.from(world.changeSubscriber.getSubscribedAtoms())).toEqual([
80 | name,
81 | ]);
82 | act(() => world.capabilities.set(name, 'nora'));
83 | await waitFor(() => screen.getByDisplayValue('nora'));
84 | });
85 |
86 | it('rerenders when derived atom changes', async () => {
87 | const world = World.syncWorld();
88 | render(
89 |
90 |
92 | );
93 | act(() => world.capabilities.set(name, 'nora'));
94 | await waitFor(() => screen.getByDisplayValue('NORA'));
95 | });
96 |
97 | it('can change atoms', () => {
98 | const world = World.syncWorld();
99 | render(
100 |
101 |
103 | );
104 |
105 | userEvent.type(screen.getByTitle('name'), ' tl');
106 |
107 | expect(world.capabilities.get(name)).toBe('jake tl');
108 | });
109 |
110 | it('does not leak effects', async () => {
111 | const leaky = atom('leaky');
112 | const world = World.syncWorld();
113 | const { unmount } = render(
114 |
115 |
117 | );
118 | await waitFor(() => screen.getByTitle('name'));
119 | unmount();
120 |
121 | expect(Array.from(world.changeSubscriber.getSubscribedAtoms())).toEqual([]);
122 | });
123 |
--------------------------------------------------------------------------------
/packages/state/src/lib/withJotaiState.tsx:
--------------------------------------------------------------------------------
1 | import { atom, Atom, Getter, Setter } from 'jotai';
2 | import * as React from 'react';
3 | import { useCallback, useEffect, useRef, useState } from 'react';
4 | import { callWithCapability } from '..';
5 | import { useWorld } from './WorldProvider';
6 |
7 | type AnyAtom = Atom;
8 | type RunAction = (perform: (get: Getter, set: Setter) => R) => R;
9 |
10 | /**
11 | * Props provided to class-based Jotai components by `classComponentWithJotai`.
12 | */
13 | export type WithJotaiProps = {
14 | /** Get state of atom, and possibly subscribe to it */
15 | get: Getter;
16 | /** Perform an action */
17 | act: RunAction;
18 | /** Forces a re-render of pure components */
19 | _revision: number;
20 | /** Used to make render reactive */
21 | _render: (render: () => React.ReactNode) => React.ReactNode;
22 | };
23 |
24 | /**
25 | * Higher order component that wraps a class component's `render` method to make
26 | * it more reactive.
27 | *
28 | * These components require a to be present in the component tree.
29 | *
30 | * Status: crazy, untested idea.
31 | */
32 | export function classComponentWithJotai<
33 | Props,
34 | ComponentT extends React.Component
35 | >(
36 | Component: React.ComponentClass,
37 | displayName?: string
38 | ): React.FunctionComponent> {
39 | // Wrap the render method to make it reactive.
40 | if (!(typeof Component.prototype.render === 'function')) {
41 | throw new Error(
42 | 'Component must have a render method on its prototype we can make reactive'
43 | );
44 | }
45 |
46 | class ReactiveSubclass extends Component {
47 | override render() {
48 | return this.props._render(() => super.render());
49 | }
50 | }
51 |
52 | Object.defineProperty(ReactiveSubclass, 'name', {
53 | value: displayName ?? Component.name,
54 | configurable: true,
55 | writable: false,
56 | enumerable: false,
57 | });
58 |
59 | const WrappedComponent = React.forwardRef(
60 | (props: Props, ref: React.Ref) => {
61 | const world = useWorld();
62 | const [revision, setRevision] = useState(0);
63 | const mounted = useRef(true);
64 | const iteration = useRef(0);
65 | const rendering = useRef(false);
66 | const subscriptions = useRef(
67 | new Map void }>()
68 | );
69 |
70 | const forceRender = useCallback(() => {
71 | if (mounted.current) {
72 | setRevision((r) => r + 1);
73 | }
74 | }, []);
75 |
76 | const getAndSubscribe = useCallback(
77 | function (atom: Atom): T {
78 | const subscription = subscriptions.current.get(atom) || {
79 | iteration: iteration.current,
80 | unsubscribe: world.changeSubscriber.subscribeChangeEffect(
81 | atom,
82 | forceRender
83 | ),
84 | };
85 | subscription.iteration = iteration.current;
86 | subscriptions.current.set(atom, subscription);
87 |
88 | return world.capabilities.get(atom);
89 | },
90 | [world, forceRender]
91 | );
92 |
93 | const getAtom: Getter = useCallback(
94 | (atom: AnyAtom) => {
95 | if (rendering.current && mounted.current) {
96 | return getAndSubscribe(atom);
97 | } else {
98 | return world.capabilities.get(atom);
99 | }
100 | },
101 | [getAndSubscribe, world]
102 | );
103 |
104 | const act: RunAction = useCallback(
105 | function (perform: (getter: Getter, setter: Setter) => R): R {
106 | // eslint-disable-next-line @typescript-eslint/no-explicit-any
107 | let result: any;
108 | const writeOnlyAtom = atom(
109 | () => undefined,
110 | (get, set) => {
111 | result = callWithCapability({ get, set }, () =>
112 | perform(get, set)
113 | );
114 | }
115 | );
116 | world.capabilities.set(writeOnlyAtom, undefined);
117 | return result;
118 | },
119 | [world]
120 | );
121 |
122 | const _render = useCallback(
123 | (renderFn: () => React.ReactNode) => {
124 | rendering.current = true;
125 | iteration.current++;
126 | try {
127 | const result = callWithCapability({ get: getAtom }, renderFn);
128 | for (const [atom, subscription] of subscriptions.current) {
129 | if (subscription.iteration !== iteration.current) {
130 | subscription.unsubscribe();
131 | subscriptions.current.delete(atom);
132 | }
133 | }
134 | return result;
135 | } finally {
136 | rendering.current = false;
137 | }
138 | },
139 | [getAtom]
140 | );
141 |
142 | useEffect(() => {
143 | const res = () => {
144 | mounted.current = false;
145 | // eslint-disable-next-line react-hooks/exhaustive-deps
146 | for (const { unsubscribe } of subscriptions.current.values()) {
147 | unsubscribe();
148 | }
149 | };
150 | return res;
151 | }, []);
152 |
153 | const enhancedProps: WithJotaiProps = {
154 | get: getAtom,
155 | act,
156 | _revision: revision,
157 | _render,
158 | };
159 |
160 | return /tsconfig.spec.json',
7 | },
8 | },
9 | testEnvironment: 'node',
10 | transform: {
11 | '^.+\\.[tj]sx?$': 'ts-jest',
12 | },
13 | moduleFileExtensions: ['ts', 'tsx', 'js', 'jsx'],
14 | coverageDirectory: '../../coverage/packages/util',
15 | };
16 |
--------------------------------------------------------------------------------
/packages/util/package.json:
--------------------------------------------------------------------------------
1 | {
2 | "name": "@jitl/util",
3 | "version": "0.0.3"
4 | }
5 |
--------------------------------------------------------------------------------
/packages/util/project.json:
--------------------------------------------------------------------------------
1 | {
2 | "root": "packages/util",
3 | "sourceRoot": "packages/util/src",
4 | "projectType": "library",
5 | "targets": {
6 | "lint": {
7 | "executor": "@nrwl/linter:eslint",
8 | "outputs": ["{options.outputFile}"],
9 | "options": {
10 | "lintFilePatterns": ["packages/util/**/*.ts"]
11 | }
12 | },
13 | "test": {
14 | "executor": "@nrwl/jest:jest",
15 | "outputs": ["coverage/packages/util"],
16 | "options": {
17 | "jestConfig": "packages/util/jest.config.js",
18 | "passWithNoTests": true
19 | }
20 | },
21 | "build": {
22 | "executor": "@nrwl/node:package",
23 | "outputs": ["{options.outputPath}"],
24 | "options": {
25 | "outputPath": "dist/packages/util",
26 | "tsConfig": "packages/util/tsconfig.lib.json",
27 | "packageJson": "packages/util/package.json",
28 | "main": "packages/util/src/index.ts",
29 | "assets": ["packages/util/*.md"]
30 | }
31 | }
32 | },
33 | "tags": []
34 | }
35 |
--------------------------------------------------------------------------------
/packages/util/src/index.ts:
--------------------------------------------------------------------------------
1 | export * from './lib/object';
2 | export * from './lib/map';
3 | export * from './lib/memo';
4 | export * from './lib/typeAssertions';
5 | export * from './lib/typeGuards';
6 | export * from './lib/types';
7 |
--------------------------------------------------------------------------------
/packages/util/src/lib/map.spec.ts:
--------------------------------------------------------------------------------
1 | import { mapMustGet } from '..';
2 | import { mapGetOrCreate } from './map';
3 |
4 | describe(mapGetOrCreate, () => {
5 | it('should return existing', () => {
6 | const map = new Map([[1, 1]]);
7 | const result = mapGetOrCreate(map, 1, () => 2);
8 | expect(result).toEqual({ value: 1, created: false });
9 | });
10 |
11 | it('should create if missing', () => {
12 | const map = new Map();
13 | const result = mapGetOrCreate(map, 1, () => 2);
14 | expect(result).toEqual({ value: 2, created: true });
15 | expect(map.has(1)).toBe(true);
16 | expect(map.get(1)).toBe(2);
17 | });
18 | });
19 |
20 | describe(mapMustGet, () => {
21 | it('should return existing', () => {
22 | const map = new Map([[1, 1]]);
23 | const result = mapMustGet(map, 1);
24 | expect(result).toBe(1);
25 | });
26 |
27 | it('should throw if missing', () => {
28 | const map = new Map();
29 | expect(() => mapMustGet(map, 1)).toThrowError(/Missing key 1/);
30 | });
31 | });
32 |
--------------------------------------------------------------------------------
/packages/util/src/lib/map.ts:
--------------------------------------------------------------------------------
1 | export interface MapLike {
2 | get(key: K): V | undefined;
3 | has(key: K): boolean;
4 | set(key: K, value: V): void;
5 | }
6 |
7 | /**
8 | * Get a value from a map-like object if present, or create the value if missing.
9 | * @param map map-like object
10 | * @param key key
11 | * @param create produce a value if missing
12 | * @returns existing or newly-created value
13 | */
14 | export function mapGetOrCreate(
15 | map: MapLike,
16 | key: K,
17 | create: () => V
18 | ): { value: V; created: boolean } {
19 | if (map.has(key)) {
20 | // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
21 | return { value: map.get(key)!, created: false };
22 | }
23 | const value = create();
24 | map.set(key, value);
25 | return { value, created: true };
26 | }
27 |
28 | export function mapMustGet(map: MapLike, key: K): V {
29 | if (!map.has(key)) {
30 | throw new Error(`Missing key ${key}`);
31 | }
32 |
33 | return map.get(key) as V;
34 | }
35 |
--------------------------------------------------------------------------------
/packages/util/src/lib/memo.test.ts:
--------------------------------------------------------------------------------
1 | import { memoizeWithWeakMap, memoizeWithLRU } from './memo';
2 |
3 | describe(memoizeWithWeakMap, () => {
4 | it('should memoize with weak map', () => {
5 | const fn = jest.fn((a: object, b: object) => Object.keys(a).concat(Object.keys(b)));
6 | const memoized = memoizeWithWeakMap(fn);
7 | const foo = { foo: 1 };
8 | const bar = { bar: 2 };
9 | const baz = { baz: 3 };
10 |
11 | expect(memoized(foo, bar)).toEqual(['foo', 'bar']);
12 | expect(memoized(foo, bar)).toEqual(['foo', 'bar']);
13 | expect(fn).toHaveBeenCalledTimes(1);
14 |
15 | expect(memoized(foo, baz)).toEqual(['foo', 'baz']);
16 | expect(memoized(foo, baz)).toEqual(['foo', 'baz']);
17 | expect(fn).toHaveBeenCalledTimes(2);
18 | });
19 |
20 | it('throws when called with non-object', () => {
21 | const fn = jest.fn();
22 | const memoized = memoizeWithWeakMap(fn);
23 | expect(() => memoized(1, 2)).toThrow(/weak map key/);
24 | });
25 |
26 | it('has no size limit', () => {
27 | const fn = jest.fn((a: object, b: object) => Object.keys(a).concat(Object.keys(b)));
28 | const memoized = memoizeWithWeakMap(fn);
29 |
30 | const N = 10000;
31 | const pairs = [];
32 | for (let i = 0; i < N; i++) {
33 | const a = { a: 1 };
34 | const b = { b: 2 };
35 | pairs.push([a, b]);
36 | expect(memoized(a, b)).toEqual(['a', 'b']);
37 | expect(memoized(a, b)).toEqual(['a', 'b']);
38 | }
39 | for (const [a, b] of pairs) {
40 | // expect(memoized(a, b)).toEqual(['a', 'b']);
41 | }
42 | expect(fn).toBeCalledTimes(N);
43 | });
44 | });
45 |
46 | describe(memoizeWithLRU, () => {
47 | function withNEntries(N: number) {
48 | describe(`with ${N} entries`, () => {
49 | it('can remember a function with several arguments', () => {
50 | const sum = (...args: number[]) => args.reduce((a, b) => a + b, 0);
51 | const fn = jest.fn(sum);
52 | const memo = memoizeWithLRU(N, fn);
53 |
54 | for (let i = 0; i < N; i++) {
55 | expect(memo(i, N - i)).toBe(i + N - i);
56 | }
57 | for (let i = 0; i < N; i++) {
58 | expect(memo(i, N - i)).toBe(i + N - i);
59 | }
60 | expect(fn).toHaveBeenCalledTimes(N);
61 |
62 | memo(-1, -2);
63 | expect(fn).toHaveBeenCalledTimes(N + 1);
64 | if (N > 1) {
65 | memo(-1, -2);
66 | expect(fn).toHaveBeenCalledTimes(N + 1);
67 | }
68 |
69 | fn.mockClear();
70 |
71 | const args = [];
72 | for (let i = 0; i < N; i++) {
73 | args.push(i * i);
74 | expect(memo(...args)).toEqual(sum(...args));
75 | expect(memo(...args)).toEqual(sum(...args));
76 | }
77 | expect(fn).toHaveBeenCalledTimes(N);
78 | });
79 |
80 | it(`can remember ${N} previous calls`, () => {
81 | const fn = jest.fn((val: number) => val * val);
82 | const memo = memoizeWithLRU(N, fn);
83 | for (let i = 0; i < N; i++) {
84 | expect(memo(i)).toBe(i * i);
85 | }
86 | for (let i = 0; i < N; i++) {
87 | expect(memo(i)).toBe(i * i);
88 | }
89 | expect(fn).toHaveBeenCalledTimes(N);
90 |
91 | // This should force i = 0 to recompute
92 | memo(N);
93 | fn.mockClear();
94 |
95 | // This will drop i = 1
96 | memo(0);
97 | expect(fn).toHaveBeenCalledTimes(1);
98 |
99 | if (N > 2) {
100 | memo(2);
101 | expect(fn).toHaveBeenCalledTimes(1);
102 | }
103 | });
104 | });
105 | }
106 |
107 | withNEntries(0);
108 | withNEntries(1);
109 | withNEntries(2);
110 | withNEntries(11);
111 | withNEntries(100);
112 | });
113 |
--------------------------------------------------------------------------------
/packages/util/src/lib/memo.ts:
--------------------------------------------------------------------------------
1 | import { mapMustGet } from '..';
2 | import { mapGetOrCreate, MapLike } from './map';
3 | import { assertDefined, mustBeDefined } from './typeAssertions';
4 |
5 | interface MapDeleteLike extends MapLike {
6 | size?: number;
7 | delete(key: K): boolean;
8 | }
9 |
10 | interface MemoNode {
11 | memo?: R;
12 | children?: MapDeleteLike>;
13 | }
14 |
15 | export function memoizeWithWeakMap(
16 | fn: (...args: Args) => R
17 | ): (...args: Args) => R {
18 | const root: MemoNode = {};
19 | return (...args: Args): R => {
20 | let node = root;
21 | for (const arg of args) {
22 | node.children ??= new WeakMap();
23 | node = mapGetOrCreate(node.children, arg, () => ({})).value;
24 | }
25 |
26 | if ('memo' in node) {
27 | return node.memo as R;
28 | }
29 |
30 | node.memo = fn(...args);
31 | return node.memo;
32 | };
33 | }
34 |
35 | function memoIsEmpty(node: MemoNode) {
36 | if ('memo' in node) {
37 | return false;
38 | }
39 |
40 | if (node.children) {
41 | return node.children.size === 0;
42 | }
43 |
44 | return true;
45 | }
46 |
47 | export function memoizeWithLRU(
48 | limit: number,
49 | fn: (...args: Args) => R
50 | ): (...args: Args) => R {
51 | if (limit < 1) {
52 | return fn;
53 | }
54 |
55 | const root: MemoNode<{ result: R; args: Args }> = {};
56 | const lru: Args[] = [];
57 | const infinite = limit === Infinity;
58 |
59 | return (...args: Args) => {
60 | let node = root;
61 | for (const arg of args) {
62 | node.children ??= new Map();
63 | node = mapGetOrCreate(node.children, arg, () => ({})).value;
64 | }
65 |
66 | if (node.memo) {
67 | if (!infinite) {
68 | lru.splice(lru.indexOf(node.memo.args), 1);
69 | lru.push(node.memo.args);
70 | }
71 | return node.memo.result;
72 | }
73 |
74 | const result = fn(...args);
75 | node.memo = {
76 | args,
77 | result,
78 | };
79 | if (!infinite) {
80 | lru.push(args);
81 | }
82 |
83 | if (lru.length > limit) {
84 | const del = lru.shift();
85 | if (del) {
86 | let delNode = root;
87 | const parents: Array = [];
88 | for (const arg of del) {
89 | assertDefined(delNode.children);
90 | parents.push(delNode);
91 | delNode = mapMustGet(delNode.children, arg);
92 | }
93 |
94 | delete delNode.memo;
95 |
96 | for (let i = del.length - 1; i >= 0; i--) {
97 | const arg = del[i];
98 | const argParent = mustBeDefined(parents[i]);
99 | if (memoIsEmpty(delNode)) {
100 | assertDefined(argParent.children);
101 | argParent.children.delete(arg);
102 | delNode = argParent;
103 | } else {
104 | break;
105 | }
106 | }
107 | }
108 | }
109 |
110 | return result;
111 | };
112 | }
113 |
--------------------------------------------------------------------------------
/packages/util/src/lib/object.test.ts:
--------------------------------------------------------------------------------
1 | import { objectKeys, objectEntries } from './object';
2 | import * as fc from 'fast-check';
3 |
4 | describe(objectKeys, () => {
5 | it('should return all keys', () => {
6 | fc.assert(
7 | fc.property(fc.object(), (value) => {
8 | expect(objectKeys(value)).toEqual(Object.keys(value));
9 | })
10 | );
11 | });
12 | });
13 |
14 | describe(objectEntries, () => {
15 | it('should return all entries', () => {
16 | fc.assert(
17 | fc.property(fc.object(), (value) => {
18 | expect(objectEntries(value)).toEqual(Object.entries(value));
19 | })
20 | );
21 | });
22 | });
23 |
--------------------------------------------------------------------------------
/packages/util/src/lib/object.ts:
--------------------------------------------------------------------------------
1 | export function objectKeys(value: T): Array {
2 | return Object.keys(value) as Array;
3 | }
4 |
5 | export type ObjectEntries = { [K in keyof T]: [K, T[K]] }[keyof T];
6 |
7 | export function objectEntries(value: T): Array> {
8 | return Object.entries(value) as Array>;
9 | }
10 |
--------------------------------------------------------------------------------
/packages/util/src/lib/typeAssertions.ts:
--------------------------------------------------------------------------------
1 | export function unreachable(value: never): never {
2 | throw new Error(`Should never occur: ${value}`);
3 | }
4 |
5 | export function mustBeDefined(value: T | undefined): T {
6 | assertDefined(value);
7 | return value;
8 | }
9 |
10 | export function assertDefined(value: T | undefined): asserts value is T {
11 | if (value === undefined) {
12 | throw new Error('Value is undefined');
13 | }
14 | }
15 |
--------------------------------------------------------------------------------
/packages/util/src/lib/typeGuards.ts:
--------------------------------------------------------------------------------
1 | export function isDefined(value: T | undefined): value is T {
2 | return value !== undefined;
3 | }
4 |
--------------------------------------------------------------------------------
/packages/util/src/lib/types.ts:
--------------------------------------------------------------------------------
1 | /**
2 | * Assert that U is assignable to T.
3 | */
4 | export type Assert = U;
5 |
6 | /**
7 | * If used for inference, validate that T is exactly Shape
8 | */
9 | export type ValidateShape = T extends Shape
10 | ? Exclude extends never
11 | ? T
12 | : never
13 | : never;
14 |
15 | export interface ExactShapeHelper {
16 | /** Declare a value that has exact type `T`. */
17 | of<
18 | /**
19 | * Inferred type of the declaration. Allowing this to be inferred is important to provide validation.
20 | * The default type provides auto-completion.
21 | */
22 | U = T
23 | >(
24 | value: ValidateShape
25 | ): U;
26 | }
27 |
28 | const STATIC_SHAPE_HELPER: ExactShapeHelper = Object.freeze({
29 | of: (value: any) => value,
30 | });
31 |
32 | // If only we could do this without a function call.
33 | // https://github.com/microsoft/TypeScript/issues/35986#issuecomment-1035310444
34 | /**
35 | * Helper to declare values of exact type `T`.
36 | *
37 | * ```typescript
38 | * const extra = { extra: true } as const
39 | * const problem: { good: true, valid: true } = {
40 | * good: true,
41 | * valid: true,
42 | * ...extra, // This is okay in Typescript
43 | * }
44 | * const solution = Exact<{ good: true, valid: true }>().of({
45 | * good: true,
46 | * valid: true,
47 | * ...extra, // Error: Not assignable to parameter of type 'never'.
48 | * })
49 | * ```
50 | */
51 | export function Exact(): ExactShapeHelper {
52 | return STATIC_SHAPE_HELPER;
53 | }
54 |
--------------------------------------------------------------------------------
/packages/util/tsconfig.json:
--------------------------------------------------------------------------------
1 | {
2 | "extends": "../../tsconfig.base.json",
3 | "files": [],
4 | "include": [],
5 | "references": [
6 | {
7 | "path": "./tsconfig.lib.json"
8 | },
9 | {
10 | "path": "./tsconfig.spec.json"
11 | }
12 | ]
13 | }
14 |
--------------------------------------------------------------------------------
/packages/util/tsconfig.lib.json:
--------------------------------------------------------------------------------
1 | {
2 | "extends": "./tsconfig.json",
3 | "compilerOptions": {
4 | "module": "commonjs",
5 | "outDir": "../../dist/out-tsc",
6 | "declaration": true,
7 | "types": ["node"]
8 | },
9 | "exclude": ["**/*.spec.ts", "**/*.test.ts"],
10 | "include": ["**/*.ts"]
11 | }
12 |
--------------------------------------------------------------------------------
/packages/util/tsconfig.spec.json:
--------------------------------------------------------------------------------
1 | {
2 | "extends": "./tsconfig.json",
3 | "compilerOptions": {
4 | "outDir": "../../dist/out-tsc",
5 | "module": "commonjs",
6 | "types": ["jest", "node"]
7 | },
8 | "include": [
9 | "**/*.test.ts",
10 | "**/*.spec.ts",
11 | "**/*.test.tsx",
12 | "**/*.spec.tsx",
13 | "**/*.test.js",
14 | "**/*.spec.js",
15 | "**/*.test.jsx",
16 | "**/*.spec.jsx",
17 | "**/*.d.ts"
18 | ]
19 | }
20 |
--------------------------------------------------------------------------------
/rebuild-api.sh:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env bash
2 |
3 | set -eo pipefail
4 |
5 | DIR="dist/packages/notion-api"
6 | TEMPDIR="dist/notion-api-temp"
7 | SAVE=(node_modules yarn.lock)
8 |
9 | mkdir -p "$TEMPDIR"
10 |
11 | for file in "${SAVE[@]}" ; do
12 | if [[ -e "$DIR/$file" ]]; then
13 | mv "$DIR/$file" "$TEMPDIR/$file"
14 | fi
15 | done
16 |
17 | yarn nx build notion-api
18 |
19 | for file in "${SAVE[@]}" ; do
20 | if [[ -e "$TEMPDIR/$file" ]]; then
21 | mv -v "$TEMPDIR/$file" "$DIR/$file"
22 | fi
23 | done
24 |
25 | cd "$DIR"
26 | yarn install
27 | yarn link
28 | yarn link @notionhq/client
29 |
--------------------------------------------------------------------------------
/tools/generators/.gitkeep:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/justjake/monorepo/d1e87174827005fa7fd6d158a0a1d7e86dd2a396/tools/generators/.gitkeep
--------------------------------------------------------------------------------
/tools/tsconfig.tools.json:
--------------------------------------------------------------------------------
1 | {
2 | "extends": "../tsconfig.base.json",
3 | "compilerOptions": {
4 | "outDir": "../dist/out-tsc/tools",
5 | "rootDir": ".",
6 | "module": "commonjs",
7 | "target": "es5",
8 | "types": ["node"],
9 | "importHelpers": false
10 | },
11 | "include": ["**/*.ts"]
12 | }
13 |
--------------------------------------------------------------------------------
/tsconfig.base.json:
--------------------------------------------------------------------------------
1 | {
2 | "compileOnSave": false,
3 | "compilerOptions": {
4 | "rootDir": ".",
5 | "sourceMap": true,
6 | "declaration": false,
7 | "moduleResolution": "node",
8 | "emitDecoratorMetadata": true,
9 | "experimentalDecorators": true,
10 | "importHelpers": true,
11 | "strict": true,
12 | "noUncheckedIndexedAccess": true,
13 | "target": "es2019",
14 | "module": "esnext",
15 | "lib": ["es2019", "dom", "DOM.Iterable"],
16 | "skipLibCheck": true,
17 | "skipDefaultLibCheck": true,
18 | "baseUrl": ".",
19 | "paths": {
20 | "@jitl/example-library": ["packages/example-library/src/index.ts"],
21 | "@jitl/notion-api": ["packages/notion-api/src/index.ts"],
22 | "@jitl/pinch-zoom": ["packages/pinch-zoom/src/index.ts"],
23 | "@jitl/state": ["packages/state/src/index.ts"],
24 | "@jitl/util": ["packages/util/src/index.ts"]
25 | }
26 | },
27 | "exclude": ["node_modules", "tmp"]
28 | }
29 |
--------------------------------------------------------------------------------
/workspace.json:
--------------------------------------------------------------------------------
1 | {
2 | "version": 2,
3 | "projects": {
4 | "example-library": "packages/example-library",
5 | "notion-api": "packages/notion-api",
6 | "pinch-zoom": "packages/pinch-zoom",
7 | "playground": "packages/playground",
8 | "playground-e2e": "packages/playground-e2e",
9 | "state": "packages/state",
10 | "util": "packages/util"
11 | }
12 | }
13 |
--------------------------------------------------------------------------------
