mirror of https://github.com/sveltejs/svelte
S. Elliott Johnson
3 years ago
parent
9007bfc3a2
commit
e77b66ed44
@ -1,258 +1,186 @@
|
||||
import {
|
||||
run_all,
|
||||
subscribe,
|
||||
noop,
|
||||
safe_not_equal,
|
||||
is_function,
|
||||
get_store_value
|
||||
} from '../internal';
|
||||
|
||||
/** Callback to inform of a value updates. */
|
||||
export type Subscriber<T> = (value: T) => void;
|
||||
|
||||
/** Unsubscribes from value updates. */
|
||||
export type Unsubscriber = () => void;
|
||||
|
||||
/** Callback to update a value. */
|
||||
export type Updater<T> = (value: T) => T;
|
||||
|
||||
/** Cleanup logic callback. */
|
||||
type Invalidator<T> = (value?: T) => void;
|
||||
|
||||
/**
|
||||
* Start and stop notification callbacks.
|
||||
* This function is called when the first subscriber subscribes.
|
||||
*
|
||||
* @param {(value: T) => void} set Function that sets the value of the store.
|
||||
* @param {(value: Updater<T>) => void} set Function that sets the value of the store after passing the current value to the update function.
|
||||
* @returns {void | (() => void)} Optionally, a cleanup function that is called when the last remaining
|
||||
* subscriber unsubscribes.
|
||||
*/
|
||||
export type StartStopNotifier<T> = (
|
||||
set: (value: T) => void,
|
||||
update: (fn: Updater<T>) => void
|
||||
) => void | (() => void);
|
||||
|
||||
/** Readable interface for subscribing. */
|
||||
export interface Readable<T> {
|
||||
/**
|
||||
* Subscribe on value changes.
|
||||
* @param run subscription callback
|
||||
* @param invalidate cleanup callback
|
||||
*/
|
||||
subscribe(this: void, run: Subscriber<T>, invalidate?: Invalidator<T>): Unsubscriber;
|
||||
}
|
||||
|
||||
/** Writable interface for both updating and subscribing. */
|
||||
export interface Writable<T> extends Readable<T> {
|
||||
/**
|
||||
* Set value and inform subscribers.
|
||||
* @param value to set
|
||||
*/
|
||||
set(this: void, value: T): void;
|
||||
|
||||
/**
|
||||
* Update value using callback and inform subscribers.
|
||||
* @param updater callback
|
||||
*/
|
||||
update(this: void, updater: Updater<T>): void;
|
||||
}
|
||||
|
||||
/** Pair of subscriber and invalidator. */
|
||||
type SubscribeInvalidateTuple<T> = [Subscriber<T>, Invalidator<T>];
|
||||
|
||||
import { run_all, subscribe, noop, safe_not_equal, is_function, get_store_value } from '../internal';
|
||||
const subscriber_queue = [];
|
||||
|
||||
/**
|
||||
* Creates a `Readable` store that allows reading by subscription.
|
||||
* @param value initial value
|
||||
* @param {StartStopNotifier} [start]
|
||||
* @param {T} value initial value
|
||||
* @param {StartStopNotifier<T>} start undefined
|
||||
* @returns {import("/Users/elliottjohnson/dev/sveltejs/svelte/index.ts-to-jsdoc").Readable<T>}
|
||||
*/
|
||||
export function readable<T>(value?: T, start?: StartStopNotifier<T>): Readable<T> {
|
||||
return {
|
||||
subscribe: writable(value, start).subscribe
|
||||
};
|
||||
export function readable(value, start) {
|
||||
return {
|
||||
subscribe: writable(value, start).subscribe
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Create a `Writable` store that allows both updating and reading by subscription.
|
||||
* @param {*=}value initial value
|
||||
* @param {StartStopNotifier=} start
|
||||
* @param {T} value initial value
|
||||
* @param {StartStopNotifier<T>} start undefined
|
||||
* @returns {import("/Users/elliottjohnson/dev/sveltejs/svelte/index.ts-to-jsdoc").Writable<T>}
|
||||
*/
|
||||
export function writable<T>(value?: T, start: StartStopNotifier<T> = noop): Writable<T> {
|
||||
let stop: Unsubscriber;
|
||||
const subscribers: Set<SubscribeInvalidateTuple<T>> = new Set();
|
||||
|
||||
function set(new_value: T): void {
|
||||
if (safe_not_equal(value, new_value)) {
|
||||
value = new_value;
|
||||
if (stop) {
|
||||
// store is ready
|
||||
const run_queue = !subscriber_queue.length;
|
||||
for (const subscriber of subscribers) {
|
||||
subscriber[1]();
|
||||
subscriber_queue.push(subscriber, value);
|
||||
}
|
||||
if (run_queue) {
|
||||
for (let i = 0; i < subscriber_queue.length; i += 2) {
|
||||
subscriber_queue[i][0](subscriber_queue[i + 1]);
|
||||
}
|
||||
subscriber_queue.length = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function update(fn: Updater<T>): void {
|
||||
set(fn(value));
|
||||
}
|
||||
|
||||
function subscribe(run: Subscriber<T>, invalidate: Invalidator<T> = noop): Unsubscriber {
|
||||
const subscriber: SubscribeInvalidateTuple<T> = [run, invalidate];
|
||||
subscribers.add(subscriber);
|
||||
if (subscribers.size === 1) {
|
||||
stop = start(set, update) || noop;
|
||||
}
|
||||
run(value);
|
||||
|
||||
return () => {
|
||||
subscribers.delete(subscriber);
|
||||
if (subscribers.size === 0 && stop) {
|
||||
stop();
|
||||
stop = null;
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
return { set, update, subscribe };
|
||||
export function writable(value, start = noop) {
|
||||
/** @type {Unsubscriber} */
|
||||
let stop;
|
||||
/** @type {Set<SubscribeInvalidateTuple<T>>} */
|
||||
const subscribers = new Set();
|
||||
/** @param {T} new_value
|
||||
* @returns {void}
|
||||
*/
|
||||
function set(new_value) {
|
||||
if (safe_not_equal(value, new_value)) {
|
||||
value = new_value;
|
||||
if (stop) {
|
||||
// store is ready
|
||||
const run_queue = !subscriber_queue.length;
|
||||
for (const subscriber of subscribers) {
|
||||
subscriber[1]();
|
||||
subscriber_queue.push(subscriber, value);
|
||||
}
|
||||
if (run_queue) {
|
||||
for (let i = 0; i < subscriber_queue.length; i += 2) {
|
||||
subscriber_queue[i][0](subscriber_queue[i + 1]);
|
||||
}
|
||||
subscriber_queue.length = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
/** @param {Updater<T>} fn
|
||||
* @returns {void}
|
||||
*/
|
||||
function update(fn) {
|
||||
set(fn(value));
|
||||
}
|
||||
/** @param {Subscriber<T>} run
|
||||
* @param {Invalidator<T>} invalidate
|
||||
* @returns {import("/Users/elliottjohnson/dev/sveltejs/svelte/index.ts-to-jsdoc").Unsubscriber}
|
||||
*/
|
||||
function subscribe(run, invalidate = noop) {
|
||||
/** @type {SubscribeInvalidateTuple<T>} */
|
||||
const subscriber = [run, invalidate];
|
||||
subscribers.add(subscriber);
|
||||
if (subscribers.size === 1) {
|
||||
stop = start(set, update) || noop;
|
||||
}
|
||||
run(value);
|
||||
return () => {
|
||||
subscribers.delete(subscriber);
|
||||
if (subscribers.size === 0 && stop) {
|
||||
stop();
|
||||
stop = null;
|
||||
}
|
||||
};
|
||||
}
|
||||
return { set, update, subscribe };
|
||||
}
|
||||
|
||||
/** One or more `Readable`s. */
|
||||
type Stores = Readable<any> | [Readable<any>, ...Array<Readable<any>>] | Array<Readable<any>>;
|
||||
|
||||
/** One or more values from `Readable` stores. */
|
||||
type StoresValues<T> = T extends Readable<infer U>
|
||||
? U
|
||||
: { [K in keyof T]: T[K] extends Readable<infer U> ? U : never };
|
||||
|
||||
/**
|
||||
* Derived value store by synchronizing one or more readable stores and
|
||||
* applying an aggregation function over its input values.
|
||||
*
|
||||
* @param stores - input stores
|
||||
* @param fn - function callback that aggregates the values
|
||||
* @param initial_value - when used asynchronously
|
||||
/** @param {Stores} stores
|
||||
* @param {Function} fn
|
||||
* @param {T} initial_value
|
||||
* @returns {import("/Users/elliottjohnson/dev/sveltejs/svelte/index.ts-to-jsdoc").Readable<T>}
|
||||
*/
|
||||
export function derived<S extends Stores, T>(
|
||||
stores: S,
|
||||
fn: (
|
||||
values: StoresValues<S>,
|
||||
set: Subscriber<T>,
|
||||
update: (fn: Updater<T>) => void
|
||||
) => Unsubscriber | void,
|
||||
initial_value?: T
|
||||
): Readable<T>;
|
||||
|
||||
/**
|
||||
* Derived value store by synchronizing one or more readable stores and
|
||||
* applying an aggregation function over its input values.
|
||||
*
|
||||
* @param stores - input stores
|
||||
* @param fn - function callback that aggregates the values
|
||||
* @param initial_value - initial value
|
||||
*/
|
||||
export function derived<S extends Stores, T>(
|
||||
stores: S,
|
||||
fn: (values: StoresValues<S>) => T,
|
||||
initial_value?: T
|
||||
): Readable<T>;
|
||||
|
||||
/**
|
||||
* Derived value store by synchronizing one or more readable stores and
|
||||
* applying an aggregation function over its input values.
|
||||
*
|
||||
* @param stores - input stores
|
||||
* @param fn - function callback that aggregates the values
|
||||
*/
|
||||
export function derived<S extends Stores, T>(
|
||||
stores: S,
|
||||
fn: (values: StoresValues<S>) => T
|
||||
): Readable<T>;
|
||||
|
||||
export function derived<T>(stores: Stores, fn: Function, initial_value?: T): Readable<T> {
|
||||
const single = !Array.isArray(stores);
|
||||
const stores_array: Array<Readable<any>> = single
|
||||
? [stores as Readable<any>]
|
||||
: (stores as Array<Readable<any>>);
|
||||
if (!stores_array.every(Boolean)) {
|
||||
throw new Error('derived() expects stores as input, got a falsy value');
|
||||
}
|
||||
|
||||
const auto = fn.length < 2;
|
||||
|
||||
return readable(initial_value, (set, update) => {
|
||||
let started = false;
|
||||
const values = [];
|
||||
|
||||
let pending = 0;
|
||||
let cleanup = noop;
|
||||
|
||||
const sync = () => {
|
||||
if (pending) {
|
||||
return;
|
||||
}
|
||||
cleanup();
|
||||
const result = fn(single ? values[0] : values, set, update);
|
||||
if (auto) {
|
||||
set(result as T);
|
||||
} else {
|
||||
cleanup = is_function(result) ? (result as Unsubscriber) : noop;
|
||||
}
|
||||
};
|
||||
|
||||
const unsubscribers = stores_array.map((store, i) =>
|
||||
subscribe(
|
||||
store,
|
||||
(value) => {
|
||||
values[i] = value;
|
||||
pending &= ~(1 << i);
|
||||
if (started) {
|
||||
sync();
|
||||
}
|
||||
},
|
||||
() => {
|
||||
pending |= 1 << i;
|
||||
}
|
||||
)
|
||||
);
|
||||
|
||||
started = true;
|
||||
sync();
|
||||
|
||||
return function stop() {
|
||||
run_all(unsubscribers);
|
||||
cleanup();
|
||||
// We need to set this to false because callbacks can still happen despite having unsubscribed:
|
||||
// Callbacks might already be placed in the queue which doesn't know it should no longer
|
||||
// invoke this derived store.
|
||||
started = false;
|
||||
};
|
||||
});
|
||||
export function derived(stores, fn, initial_value) {
|
||||
const single = !Array.isArray(stores);
|
||||
/** @type {Array<Readable<any>>} */
|
||||
const stores_array = single
|
||||
? [stores]
|
||||
: stores;
|
||||
if (!stores_array.every(Boolean)) {
|
||||
throw new Error('derived() expects stores as input, got a falsy value');
|
||||
}
|
||||
const auto = fn.length < 2;
|
||||
return readable(initial_value, (set, update) => {
|
||||
let started = false;
|
||||
const values = [];
|
||||
let pending = 0;
|
||||
let cleanup = noop;
|
||||
const sync = () => {
|
||||
if (pending) {
|
||||
return;
|
||||
}
|
||||
cleanup();
|
||||
const result = fn(single ? values[0] : values, set, update);
|
||||
if (auto) {
|
||||
set(result);
|
||||
}
|
||||
else {
|
||||
cleanup = is_function(result) ? result : noop;
|
||||
}
|
||||
};
|
||||
const unsubscribers = stores_array.map((store, i) => subscribe(store, (value) => {
|
||||
values[i] = value;
|
||||
pending &= ~(1 << i);
|
||||
if (started) {
|
||||
sync();
|
||||
}
|
||||
}, () => {
|
||||
pending |= 1 << i;
|
||||
}));
|
||||
started = true;
|
||||
sync();
|
||||
return function stop() {
|
||||
run_all(unsubscribers);
|
||||
cleanup();
|
||||
// We need to set this to false because callbacks can still happen despite having unsubscribed:
|
||||
// Callbacks might already be placed in the queue which doesn't know it should no longer
|
||||
// invoke this derived store.
|
||||
started = false;
|
||||
};
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Takes a store and returns a new one derived from the old one that is readable.
|
||||
*
|
||||
* @param store - store to make readonly
|
||||
* @param {Readable<T>} store - store to make readonly
|
||||
* @returns {import("/Users/elliottjohnson/dev/sveltejs/svelte/index.ts-to-jsdoc").Readable<T>}
|
||||
*/
|
||||
export function readonly<T>(store: Readable<T>): Readable<T> {
|
||||
return {
|
||||
subscribe: store.subscribe.bind(store)
|
||||
};
|
||||
export function readonly(store) {
|
||||
return {
|
||||
subscribe: store.subscribe.bind(store)
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the current value from a store by subscribing and immediately unsubscribing.
|
||||
* @param store readable
|
||||
*/
|
||||
export { get_store_value as get };
|
||||
|
||||
|
||||
/**
|
||||
* @typedef {(value: T) => void} Subscriber
|
||||
* @template T
|
||||
*/
|
||||
/** @typedef {() => void} Unsubscriber */
|
||||
/**
|
||||
* @typedef {(value: T) => T} Updater
|
||||
* @template T
|
||||
*/
|
||||
/**
|
||||
* @typedef {(value?: T) => void} Invalidator
|
||||
* @template T
|
||||
*/
|
||||
/**
|
||||
* @typedef {(
|
||||
* set: (value: T) => void,
|
||||
* update: (fn: Updater<T>) => void
|
||||
* ) => void | (() => void)} StartStopNotifier
|
||||
* @template T
|
||||
*/
|
||||
/**
|
||||
* @typedef {[Subscriber<T>, Invalidator<T>]} SubscribeInvalidateTuple
|
||||
* @template T
|
||||
*/
|
||||
/** @typedef {Readable<any> | [Readable<any>, ...Array<Readable<any>>] | Array<Readable<any>>} Stores */
|
||||
/**
|
||||
* @typedef {T extends Readable<infer U>
|
||||
* ? U
|
||||
* : { [K in keyof T]: T[K] extends Readable<infer U> ? U : never }} StoresValues
|
||||
* @template T
|
||||
*/
|
||||
|
||||
/**
|
||||
* Readable interface for subscribing.
|
||||
* @typedef {Object} Readable
|
||||
*/
|
||||
/**
|
||||
* Writable interface for both updating and subscribing.
|
||||
* @typedef {Object} Writable
|
||||
*/
|
||||
Loading…
Reference in new issue