remove unused arg

blockless
Rich Harris 2 years ago
parent db2ffd78b6
commit a8bbc8b8a2

@ -43,7 +43,7 @@ export function await_block(anchor_node, get_input, pending_fn, then_fn, catch_f
if (pending_effect) { if (pending_effect) {
resume_effect(pending_effect); resume_effect(pending_effect);
} else if (pending_fn) { } else if (pending_fn) {
pending_effect = render_effect(() => pending_fn(anchor_node), {}, true); pending_effect = render_effect(() => pending_fn(anchor_node), true);
} }
if (then_effect) { if (then_effect) {
@ -74,7 +74,7 @@ export function await_block(anchor_node, get_input, pending_fn, then_fn, catch_f
} else if (then_fn) { } else if (then_fn) {
set_current_effect(branch); set_current_effect(branch);
set_current_component_context(component_context); set_current_component_context(component_context);
then_effect = render_effect(() => then_fn(anchor_node, value), {}, true); then_effect = render_effect(() => then_fn(anchor_node, value), true);
set_current_component_context(null); set_current_component_context(null);
set_current_effect(null); set_current_effect(null);
} }
@ -97,7 +97,7 @@ export function await_block(anchor_node, get_input, pending_fn, then_fn, catch_f
} else if (catch_fn) { } else if (catch_fn) {
set_current_effect(branch); set_current_effect(branch);
set_current_component_context(component_context); set_current_component_context(component_context);
catch_effect = render_effect(() => catch_fn(anchor_node, error), {}, true); catch_effect = render_effect(() => catch_fn(anchor_node, error), true);
set_current_component_context(null); set_current_component_context(null);
set_current_effect(null); set_current_effect(null);
} }
@ -115,7 +115,7 @@ export function await_block(anchor_node, get_input, pending_fn, then_fn, catch_f
} else if (then_fn) { } else if (then_fn) {
// TODO we need to pass a function in rather than a value, because // TODO we need to pass a function in rather than a value, because
// this will never update // this will never update
then_effect = render_effect(() => then_fn(anchor_node, input), {}, true); then_effect = render_effect(() => then_fn(anchor_node, input), true);
} }
if (catch_effect) { if (catch_effect) {

@ -396,7 +396,6 @@ export function each_indexed(anchor_node, collection, flags, render_fn, fallback
}, },
i i
), ),
{},
true true
); );
} }
@ -416,7 +415,7 @@ export function each_indexed(anchor_node, collection, flags, render_fn, fallback
if (alternate) { if (alternate) {
resume_effect(alternate); resume_effect(alternate);
} else if (fallback_fn) { } else if (fallback_fn) {
alternate = render_effect(() => fallback_fn(anchor_node), {}, true); alternate = render_effect(() => fallback_fn(anchor_node), true);
} }
} else if (alternate) { } else if (alternate) {
pause_effect(alternate, () => { pause_effect(alternate, () => {
@ -616,13 +615,9 @@ function each_item_block(item, key, index, render_fn, flags) {
const index_value = (flags & EACH_INDEX_REACTIVE) === 0 ? index : source(index); const index_value = (flags & EACH_INDEX_REACTIVE) === 0 ? index : source(index);
const block = create_each_item_block(item_value, index_value, key); const block = create_each_item_block(item_value, index_value, key);
const effect = render_effect( const effect = render_effect(() => {
() => {
render_fn(null, block.v, block.i); render_fn(null, block.v, block.i);
}, }, true);
block,
true
);
block.e = effect; block.e = effect;
return block; return block;

@ -55,7 +55,7 @@ export function if_block(anchor_node, condition_fn, consequent_fn, alternate_fn)
if (consequent_effect) { if (consequent_effect) {
resume_effect(consequent_effect); resume_effect(consequent_effect);
} else { } else {
consequent_effect = render_effect(() => consequent_fn(anchor_node), {}, true); consequent_effect = render_effect(() => consequent_fn(anchor_node), true);
} }
if (alternate_effect) { if (alternate_effect) {
@ -67,7 +67,7 @@ export function if_block(anchor_node, condition_fn, consequent_fn, alternate_fn)
if (alternate_effect) { if (alternate_effect) {
resume_effect(alternate_effect); resume_effect(alternate_effect);
} else { } else {
alternate_effect = alternate_fn && render_effect(() => alternate_fn(anchor_node), {}, true); alternate_effect = alternate_fn && render_effect(() => alternate_fn(anchor_node), true);
} }
if (consequent_effect) { if (consequent_effect) {

@ -27,6 +27,6 @@ export function key_block(anchor_node, get_key, render_fn) {
pause_effect(e, noop); pause_effect(e, noop);
} }
effect = render_effect(() => render_fn(anchor_node), {}, true); effect = render_effect(() => render_fn(anchor_node), true);
}).f |= BRANCH_EFFECT; }).f |= BRANCH_EFFECT;
} }

@ -22,6 +22,6 @@ export function snippet_effect(get_snippet, node, ...args) {
destroy_effect(effect); destroy_effect(effect);
} }
effect = render_effect(() => untrack(() => snippet(node, ...args)), {}, true); effect = render_effect(() => untrack(() => snippet(node, ...args)), true);
}); });
} }

@ -29,7 +29,7 @@ export function component(anchor_node, component_fn, render_fn) {
} }
if (Component) { if (Component) {
effect = render_effect(() => render_fn(/** @type {C} */ (Component)), {}, true); effect = render_effect(() => render_fn(/** @type {C} */ (Component)), true);
} }
}); });
} }

@ -71,7 +71,7 @@ export function element(anchor_node, get_tag, is_svg, render_fn) {
destroy_effect(block); destroy_effect(block);
} }
block = render_effect(() => render_fn(next_element, anchor_node), {}, true); // TODO disable transitions block = render_effect(() => render_fn(next_element, anchor_node), true); // TODO disable transitions
} }
} else if (block) { } else if (block) {
const old_element = element; const old_element = element;
@ -103,7 +103,7 @@ export function element(anchor_node, get_tag, is_svg, render_fn) {
if (block) { if (block) {
resume_effect(block); resume_effect(block);
} else { } else {
block = render_effect(() => render_fn(next_element, anchor), {}, true); block = render_effect(() => render_fn(next_element, anchor), true);
} }
} }
} }

@ -72,11 +72,10 @@ export function push_reference(target_signal, ref_signal) {
* @param {import('../types.js').EffectType} type * @param {import('../types.js').EffectType} type
* @param {(() => void | (() => void))} fn * @param {(() => void | (() => void))} fn
* @param {boolean} sync * @param {boolean} sync
* @param {null} block
* @param {boolean} schedule * @param {boolean} schedule
* @returns {import('../types.js').EffectSignal} * @returns {import('../types.js').EffectSignal}
*/ */
function internal_create_effect(type, fn, sync, block, schedule) { function internal_create_effect(type, fn, sync, schedule) {
const signal = create_computation_signal(type | DIRTY, null); const signal = create_computation_signal(type | DIRTY, null);
signal.i = fn; signal.i = fn;
signal.x = current_component_context; signal.x = current_component_context;
@ -115,13 +114,7 @@ export function user_effect(fn) {
current_component_context !== null && current_component_context !== null &&
!current_component_context.m; !current_component_context.m;
const effect = internal_create_effect( const effect = internal_create_effect(EFFECT, fn, false, !apply_component_effect_heuristics);
EFFECT,
fn,
false,
null,
!apply_component_effect_heuristics
);
if (apply_component_effect_heuristics) { if (apply_component_effect_heuristics) {
const context = /** @type {import('../types.js').ComponentContext} */ ( const context = /** @type {import('../types.js').ComponentContext} */ (
@ -139,7 +132,7 @@ export function user_effect(fn) {
* @returns {() => void} * @returns {() => void}
*/ */
export function user_root_effect(fn) { export function user_root_effect(fn) {
const effect = internal_create_effect(RENDER_EFFECT | ROOT_EFFECT, fn, true, null, true); const effect = internal_create_effect(RENDER_EFFECT | ROOT_EFFECT, fn, true, true);
return () => { return () => {
destroy_effect(effect); destroy_effect(effect);
}; };
@ -150,7 +143,7 @@ export function user_root_effect(fn) {
* @returns {import('../types.js').EffectSignal} * @returns {import('../types.js').EffectSignal}
*/ */
export function effect(fn) { export function effect(fn) {
return internal_create_effect(EFFECT, fn, false, null, true); return internal_create_effect(EFFECT, fn, false, true);
} }
/** /**
@ -158,7 +151,7 @@ export function effect(fn) {
* @returns {import('../types.js').EffectSignal} * @returns {import('../types.js').EffectSignal}
*/ */
export function managed_effect(fn) { export function managed_effect(fn) {
return internal_create_effect(EFFECT | MANAGED, fn, false, null, true); return internal_create_effect(EFFECT | MANAGED, fn, false, true);
} }
/** /**
@ -167,7 +160,7 @@ export function managed_effect(fn) {
* @returns {import('../types.js').EffectSignal} * @returns {import('../types.js').EffectSignal}
*/ */
export function managed_pre_effect(fn, sync) { export function managed_pre_effect(fn, sync) {
return internal_create_effect(PRE_EFFECT | MANAGED, fn, sync, null, true); return internal_create_effect(PRE_EFFECT | MANAGED, fn, sync, true);
} }
/** /**
@ -193,7 +186,6 @@ export function pre_effect(fn) {
return val; return val;
}, },
sync, sync,
null,
true true
); );
} }
@ -206,22 +198,21 @@ export function pre_effect(fn) {
* @returns {import('../types.js').EffectSignal} * @returns {import('../types.js').EffectSignal}
*/ */
export function invalidate_effect(fn) { export function invalidate_effect(fn) {
return internal_create_effect(PRE_EFFECT, fn, true, null, true); return internal_create_effect(PRE_EFFECT, fn, true, true);
} }
/** /**
* @param {() => void | (() => void)} fn * @param {() => void | (() => void)} fn
* @param {null} block * @param {boolean} managed
* @param {any} managed * @param {boolean} sync
* @param {any} sync
* @returns {import('../types.js').EffectSignal} * @returns {import('../types.js').EffectSignal}
*/ */
export function render_effect(fn, block = null, managed = false, sync = true) { export function render_effect(fn, managed = false, sync = true) {
let flags = RENDER_EFFECT; let flags = RENDER_EFFECT;
if (managed) { if (managed) {
flags |= MANAGED; flags |= MANAGED;
} }
return internal_create_effect(flags, /** @type {any} */ (fn), sync, null, true); return internal_create_effect(flags, /** @type {any} */ (fn), sync, true);
} }
/** /**
@ -234,7 +225,7 @@ export function derived(fn) {
const is_unowned = current_effect === null; const is_unowned = current_effect === null;
const flags = is_unowned ? DERIVED | UNOWNED : DERIVED; const flags = is_unowned ? DERIVED | UNOWNED : DERIVED;
const signal = /** @type {import('../types.js').ComputationSignal<V>} */ ( const signal = /** @type {import('../types.js').ComputationSignal<V>} */ (
create_computation_signal(flags | CLEAN, UNINITIALIZED, null) create_computation_signal(flags | CLEAN, UNINITIALIZED)
); );
signal.i = fn; signal.i = fn;
signal.e = default_equals; signal.e = default_equals;

@ -2303,8 +2303,7 @@ function _mount(Component, options) {
// @ts-expect-error will be defined because the render effect runs synchronously // @ts-expect-error will be defined because the render effect runs synchronously
let component = undefined; let component = undefined;
const effect = render_effect( const effect = render_effect(() => {
() => {
if (options.context) { if (options.context) {
push({}); push({});
/** @type {import('../client/types.js').ComponentContext} */ (current_component_context).c = /** @type {import('../client/types.js').ComponentContext} */ (current_component_context).c =
@ -2323,10 +2322,7 @@ function _mount(Component, options) {
if (options.context) { if (options.context) {
pop(); pop();
} }
}, }, true);
{},
true
);
const bound_event_listener = handle_event_propagation.bind(null, container); const bound_event_listener = handle_event_propagation.bind(null, container);
const bound_document_event_listener = handle_event_propagation.bind(null, document); const bound_document_event_listener = handle_event_propagation.bind(null, document);

@ -24,7 +24,6 @@ function run_test(runes: boolean, fn: (runes: boolean) => () => void) {
() => { () => {
execute = fn(runes); execute = fn(runes);
}, },
null,
true, true,
true true
); );

Loading…
Cancel
Save