@ -2,16 +2,20 @@ import { DEV } from 'esm-env';
import { subscribe _to _store } from '../../store/utils.js' ; import { subscribe _to _store } from '../../store/utils.js' ;
import { EMPTY _FUNC , run _all } from '../common.js' ; import { EMPTY _FUNC , run _all } from '../common.js' ;
import { get _descriptor , get _descriptors , is _array } from './utils.js' ; import { get _descriptor , get _descriptors , is _array } from './utils.js' ;
import { PROPS _CALL _DEFAULT _VALUE , PROPS _IS _IMMUTABLE , PROPS _IS _RUNES } from '../../constants.js' ; import {
PROPS _IS _LAZY _INITIAL ,
PROPS _IS _IMMUTABLE ,
PROPS _IS _RUNES ,
PROPS _IS _UPDATED
} from '../../constants.js' ;
import { readonly } from './proxy/readonly.js' ; import { readonly } from './proxy/readonly.js' ;
import { observe , proxy } from './proxy/proxy.js' ; import { } from './proxy/proxy.js' ;
export const SOURCE = 1 ; export const SOURCE = 1 ;
export const DERIVED = 1 << 1 ; export const DERIVED = 1 << 1 ;
export const EFFECT = 1 << 2 ; export const EFFECT = 1 << 2 ;
export const PRE _EFFECT = 1 << 3 ; export const PRE _EFFECT = 1 << 3 ;
export const RENDER _EFFECT = 1 << 4 ; export const RENDER _EFFECT = 1 << 4 ;
export const SYNC _EFFECT = 1 << 5 ;
const MANAGED = 1 << 6 ; const MANAGED = 1 << 6 ;
const UNOWNED = 1 << 7 ; const UNOWNED = 1 << 7 ;
export const CLEAN = 1 << 8 ; export const CLEAN = 1 << 8 ;
@ -20,7 +24,7 @@ export const MAYBE_DIRTY = 1 << 10;
export const INERT = 1 << 11 ; export const INERT = 1 << 11 ;
export const DESTROYED = 1 << 12 ; export const DESTROYED = 1 << 12 ;
const IS _EFFECT = EFFECT | PRE _EFFECT | RENDER _EFFECT | SYNC _EFFECT ; const IS _EFFECT = EFFECT | PRE _EFFECT | RENDER _EFFECT ;
const FLUSH _MICROTASK = 0 ; const FLUSH _MICROTASK = 0 ;
const FLUSH _SYNC = 1 ; const FLUSH _SYNC = 1 ;
@ -536,7 +540,7 @@ function process_microtask() {
* /
* /
export function schedule _effect ( signal , sync ) { export function schedule _effect ( signal , sync ) {
const flags = signal . f ;
const flags = signal . f ;
if ( sync || ( flags & SYNC _EFFECT ) !== 0 ) {
if ( sync ) {
execute _effect ( signal ) ;
execute _effect ( signal ) ;
set _signal _status ( signal , CLEAN ) ;
set _signal _status ( signal , CLEAN ) ;
} else {
} else {
@ -1284,14 +1288,6 @@ export function invalidate_effect(init) {
return internal _create _effect ( PRE _EFFECT , init , true , current _block , true ) ;
return internal _create _effect ( PRE _EFFECT , init , true , current _block , true ) ;
} }
/ * *
* @ param { ( ) => void | ( ( ) => void ) } init
* @ returns { import ( './types.js' ) . EffectSignal }
* /
function sync _effect ( init ) {
return internal _create _effect ( SYNC _EFFECT , init , true , current _block , true ) ;
}
/ * * / * *
* @ template { import ( './types.js' ) . Block } B
* @ template { import ( './types.js' ) . Block } B
* @ param { ( block : B ) => void | ( ( ) => void ) } init
* @ param { ( block : B ) => void | ( ( ) => void ) } init
@ -1390,124 +1386,114 @@ export function is_store(val) {
/ * * / * *
* This function is responsible for synchronizing a possibly bound prop with the inner component state .
* This function is responsible for synchronizing a possibly bound prop with the inner component state .
* It is used whenever the compiler sees that the component writes to the prop .
* It is used whenever the compiler sees that the component writes to the prop , or when it has a default prop _value .
*
* - If the parent passes down a prop without binding , like ` <Component prop={value} /> ` , then create a signal
* that updates whenever the value is updated from the parent or from within the component itself
* - If the parent passes down a prop with a binding , like ` <Component bind:prop={value} /> ` , then
* - if the thing that is passed along is the original signal ( not a property on it ) , and the equality functions
* are equal , then just use that signal , no need to create an intermediate one
* - otherwise create a signal that updates whenever the value is updated from the parent , and when it ' s updated
* from within the component itself , call the setter of the parent which will propagate the value change back
* @ template V
* @ template V
* @ param { Record < string , unknown > } props
* @ param { Record < string , unknown > } props
* @ param { string } key
* @ param { string } key
* @ param { number } flags
* @ param { number } flags
* @ param { V | ( ( ) => V ) } [ default_value ]
* @ param { V | ( ( ) => V ) } [ initial ]
* @ returns { import ( './types.js' ) . Signal < V > | ( ( ) => V ) }
* @ returns { ( ( ) => V | ( ( arg : V ) => V ) | ( ( arg : V , mutation : boolean ) => V ) ) }
* /
* /
export function prop _source ( props , key , flags , default _value ) { export function prop ( props , key , flags , initial ) {
const call _default _value = ( flags & PROPS _CALL _DEFAULT _VALUE ) !== 0 ;
var immutable = ( flags & PROPS _IS _IMMUTABLE ) !== 0 ;
const immutable = ( flags & PROPS _IS _IMMUTABLE ) !== 0 ;
var runes = ( flags & PROPS _IS _RUNES ) !== 0 ;
const runes = ( flags & PROPS _IS _RUNES ) !== 0 ;
const update _bound _prop = get _descriptor ( props , key ) ? . set ;
let value = props [ key ] ;
const should _set _default _value = value === undefined && default _value !== undefined ;
if ( update _bound _prop && runes && default _value !== undefined ) {
var setter = get _descriptor ( props , key ) ? . set ;
if ( DEV && setter && runes && initial !== undefined ) {
// TODO consolidate all these random runtime errors
// TODO consolidate all these random runtime errors
throw new Error ( 'Cannot use fallback values with bind:' ) ;
throw new Error ( 'Cannot use fallback values with bind:' ) ;
}
}
if ( should _set _default _value ) {
var prop _value = /** @type {V} */ ( props [ key ] ) ;
value =
// @ts-expect-error would need a cumbersome method overload to type this
if ( prop _value === undefined && initial !== undefined ) {
call _default _value ? default _value ( ) : default _value ;
// @ts-expect-error would need a cumbersome method overload to type this
if ( ( flags & PROPS _IS _LAZY _INITIAL ) !== 0 ) initial = initial ( ) ;
if ( DEV && runes ) {
if ( DEV && runes ) {
value = readonly ( proxy ( /** @type {any} */ ( value ) ) ) ;
initial = readonly ( proxy ( /** @type {any} */ ( initial ) ) ) ;
}
}
prop _value = /** @type {V} */ ( initial ) ;
if ( setter ) setter ( prop _value ) ;
}
}
const source _signal = immutable ? source ( value ) : mutable _source ( value ) ;
var getter = ( ) => {
var value = /** @type {V} */ ( props [ key ] ) ;
if ( value !== undefined ) initial = undefined ;
return value === undefined ? /** @type {V} */ ( initial ) : value ;
} ;
// Synchronize prop changes with source signal.
// easy mode — prop is never written to
// Needs special equality checking because the prop in the
if ( ( flags & PROPS _IS _UPDATED ) === 0 ) {
// parent could be changed through `foo.bar = 'new value'`.
return getter ;
let ignore _next1 = false ;
}
let ignore _next2 = false ;
let did _update _to _defined = ! should _set _default _value ;
let mount = true ;
// intermediate mode — prop is written to, but the parent component had
sync _effect ( ( ) => {
// `bind:foo` which means we can just call `$$props.foo = value` directly
observe ( props ) ;
if ( setter ) {
return function ( /** @type {V} */ value ) {
if ( arguments . length === 1 ) {
/** @type {Function} */ ( setter ) ( value ) ;
return value ;
} else {
return getter ( ) ;
}
} ;
}
// Before if to ensure signal dependency is registered
// hard mode. this is where it gets ugly — the value in the child should
const propagating _value = props [ key ] ;
// synchronize with the parent, but it should also be possible to temporarily
if ( mount ) {
// set the value to something else locally.
mount = false ;
var from _child = false ;
return ;
var was _from _child = false ;
}
if ( ignore _next1 ) {
// The derived returns the current value. The underlying mutable
ignore _next1 = false ;
// source is written to from various places to persist this value.
return ;
var inner _current _value = mutable _source ( prop _value ) ;
var current _value = derived ( ( ) => {
var parent _value = getter ( ) ;
var child _value = get ( inner _current _value ) ;
if ( from _child ) {
from _child = false ;
was _from _child = true ;
return child _value ;
}
}
if (
was _from _child = false ;
// Ensure that updates from undefined to undefined are ignored
return ( inner _current _value . v = parent _value ) ;
( did _update _to _defined || propagating _value !== undefined ) &&
not _equal ( immutable , propagating _value , source _signal . v )
) {
ignore _next2 = true ;
did _update _to _defined = true ;
// TODO figure out why we need it this way and the explain in a comment;
// some tests fail is we just do set_signal_value(source_signal, propagating_value)
untrack ( ( ) => set _signal _value ( source _signal , propagating _value ) ) ;
}
} ) ;
} ) ;
if ( update _bound _prop !== undefined ) {
if ( ! immutable ) current _value . e = safe _equal ;
let ignore _first = ! should _set _default _value ;
sync _effect ( ( ) => {
// Before if to ensure signal dependency is registered
const propagating _value = get ( source _signal ) ;
if ( ignore _first ) {
ignore _first = false ;
return ;
}
if ( ignore _next2 ) {
ignore _next2 = false ;
return ;
}
ignore _next1 = true ;
return function ( /** @type {V} */ value , mutation = false ) {
did _update _to _defined = true ;
var current = get ( current _value ) ;
untrack ( ( ) => update _bound _prop ( propagating _value ) ) ;
} ) ;
}
return /** @type {import('./types.js').Signal<V>} */ ( source _signal ) ;
// legacy nonsense — need to ensure the source is invalidated when necessary
} if ( is _signals _recorded ) {
// set this so that we don't reset to the parent value if `d`
// is invalidated because of `invalidate_inner_signals` (rather
// than because the parent or child value changed)
from _child = was _from _child ;
// invoke getters so that signals are picked up by `invalidate_inner_signals`
getter ( ) ;
get ( inner _current _value ) ;
}
/ * * if ( arguments . length > 0 ) {
* @ param { boolean } immutable
if ( mutation || ( immutable ? value !== current : safe _not _equal ( value , current ) ) ) {
* @ param { unknown } a
from _child = true ;
* @ param { unknown } b
set ( inner _current _value , mutation ? current : value ) ;
* @ returns { boolean }
get ( current _value ) ; // force a synchronisation immediately
* /
}
function not _equal ( immutable , a , b ) {
return immutable ? immutable _not _equal ( a , b ) : safe _not _equal ( a , b ) ;
}
/ * * return value ;
* @ param { unknown } a
}
* @ param { unknown } b
* @ returns { boolean }
return current ;
* /
} ;
function immutable _not _equal ( a , b ) {
// eslint-disable-next-line eqeqeq
return a != a ? b == b : a !== b ;
} }
/ * * / * *
@ -1584,82 +1570,67 @@ export function bubble_event($$props, event) {
/ * * / * *
* @ param { import ( './types.js' ) . Signal < number > } signal
* @ param { import ( './types.js' ) . Signal < number > } signal
* @ param { 1 | - 1 } [ d ]
* @ returns { number }
* @ returns { number }
* /
* /
export function increment( signal ) { export function update( signal , d = 1 ) {
const value = get ( signal ) ;
const value = get ( signal ) ;
set _signal _value ( signal , value + 1 ) ;
set _signal _value ( signal , value + d ) ;
return value ;
return value ;
} }
/ * * / * *
* @ param { import ( './types.js' ) . Store < number > } store
* @ param { ( ( value ? : number ) => number ) } fn
* @ param { number } store _value
* @ param { 1 | - 1 } [ d ]
* @ returns { number }
* /
export function increment _store ( store , store _value ) {
store . set ( store _value + 1 ) ;
return store _value ;
}
/ * *
* @ param { import ( './types.js' ) . Signal < number > } signal
* @ returns { number }
* @ returns { number }
* /
* /
export function decrement( signal ) { export function update _prop ( fn , d = 1 ) {
const value = get( signal ) ;
const value = fn ( ) ;
set_signal _value ( signal , value - 1 ) ;
fn ( value + d ) ;
return value ;
return value ;
} }
/ * * / * *
* @ param { import ( './types.js' ) . Store < number > } store
* @ param { import ( './types.js' ) . Store < number > } store
* @ param { number } store _value
* @ param { number } store _value
* @ param { 1 | - 1 } [ d ]
* @ returns { number }
* @ returns { number }
* /
* /
export function crement _store ( store , store _value ) { export function up dat e_store ( store , store _value , d = 1 ) {
store . set ( store _value - 1 ) ;
store . set ( store _value + d ) ;
return store _value ;
return store _value ;
} }
/ * * / * *
* @ param { import ( './types.js' ) . Signal < number > } signal
* @ param { import ( './types.js' ) . Signal < number > } signal
* @ param { 1 | - 1 } [ d ]
* @ returns { number }
* @ returns { number }
* /
* /
export function increment_pre ( signal ) { export function update_pre ( signal , d = 1 ) {
const value = get ( signal ) + 1 ;
const value = get ( signal ) + d ;
set _signal _value ( signal , value ) ;
set _signal _value ( signal , value ) ;
return value ;
return value ;
} }
/ * * / * *
* @ param { import ( './types.js' ) . Store < number > } store
* @ param { ( ( value ? : number ) => number ) } fn
* @ param { number } store _value
* @ param { 1 | - 1 } [ d ]
* @ returns { number }
* /
export function increment _pre _store ( store , store _value ) {
const value = store _value + 1 ;
store . set ( value ) ;
return value ;
}
/ * *
* @ param { import ( './types.js' ) . Signal < number > } signal
* @ returns { number }
* @ returns { number }
* /
* /
export function decrement_pre ( signal ) { export function update _pre _prop ( fn , d = 1 ) {
const value = get( signal ) - 1 ;
const value = fn ( ) + d ;
set_signal _value ( signal , value ) ;
fn ( value ) ;
return value ;
return value ;
} }
/ * * / * *
* @ param { import ( './types.js' ) . Store < number > } store
* @ param { import ( './types.js' ) . Store < number > } store
* @ param { number } store _value
* @ param { number } store _value
* @ param { 1 | - 1 } [ d ]
* @ returns { number }
* @ returns { number }
* /
* /
export function crement _pre _store ( store , store _value ) { export function up dat e_pre _store ( store , store _value , d = 1 ) {
const value = store _value - 1 ;
const value = store _value + d ;
store . set ( value ) ;
store . set ( value ) ;
return value ;
return value ;
} }
Rich Harris
1 year ago
committed by
GitHub