svelte-intersection-observer 0.10.2 → 1.0.0

package/lib/index.mjs

@@ -1,712 +0,0 @@
-/** @returns {void} */
-function noop() {}
-
-/**
- * @template T
- * @template S
- * @param {T} tar
- * @param {S} src
- * @returns {T & S}
- */
-function assign(tar, src) {
-	// @ts-ignore
-	for (const k in src) tar[k] = src[k];
-	return /** @type {T & S} */ (tar);
-}
-
-function run(fn) {
-	return fn();
-}
-
-function blank_object() {
-	return Object.create(null);
-}
-
-/**
- * @param {Function[]} fns
- * @returns {void}
- */
-function run_all(fns) {
-	fns.forEach(run);
-}
-
-/**
- * @param {any} thing
- * @returns {thing is Function}
- */
-function is_function(thing) {
-	return typeof thing === 'function';
-}
-
-/** @returns {boolean} */
-function safe_not_equal(a, b) {
-	return a != a ? b == b : a !== b || (a && typeof a === 'object') || typeof a === 'function';
-}
-
-/** @returns {boolean} */
-function is_empty(obj) {
-	return Object.keys(obj).length === 0;
-}
-
-function create_slot(definition, ctx, $$scope, fn) {
-	if (definition) {
-		const slot_ctx = get_slot_context(definition, ctx, $$scope, fn);
-		return definition[0](slot_ctx);
-	}
-}
-
-function get_slot_context(definition, ctx, $$scope, fn) {
-	return definition[1] && fn ? assign($$scope.ctx.slice(), definition[1](fn(ctx))) : $$scope.ctx;
-}
-
-function get_slot_changes(definition, $$scope, dirty, fn) {
-	if (definition[2] && fn) {
-		const lets = definition[2](fn(dirty));
-		if ($$scope.dirty === undefined) {
-			return lets;
-		}
-		if (typeof lets === 'object') {
-			const merged = [];
-			const len = Math.max($$scope.dirty.length, lets.length);
-			for (let i = 0; i < len; i += 1) {
-				merged[i] = $$scope.dirty[i] | lets[i];
-			}
-			return merged;
-		}
-		return $$scope.dirty | lets;
-	}
-	return $$scope.dirty;
-}
-
-/** @returns {void} */
-function update_slot_base(
-	slot,
-	slot_definition,
-	ctx,
-	$$scope,
-	slot_changes,
-	get_slot_context_fn
-) {
-	if (slot_changes) {
-		const slot_context = get_slot_context(slot_definition, ctx, $$scope, get_slot_context_fn);
-		slot.p(slot_context, slot_changes);
-	}
-}
-
-/** @returns {any[] | -1} */
-function get_all_dirty_from_scope($$scope) {
-	if ($$scope.ctx.length > 32) {
-		const dirty = [];
-		const length = $$scope.ctx.length / 32;
-		for (let i = 0; i < length; i++) {
-			dirty[i] = -1;
-		}
-		return dirty;
-	}
-	return -1;
-}
-
-/**
- * @param {Node} node
- * @returns {void}
- */
-function detach(node) {
-	if (node.parentNode) {
-		node.parentNode.removeChild(node);
-	}
-}
-
-/**
- * @param {Element} element
- * @returns {ChildNode[]}
- */
-function children(element) {
-	return Array.from(element.childNodes);
-}
-
-/**
- * @template T
- * @param {string} type
- * @param {T} [detail]
- * @param {{ bubbles?: boolean, cancelable?: boolean }} [options]
- * @returns {CustomEvent<T>}
- */
-function custom_event(type, detail, { bubbles = false, cancelable = false } = {}) {
-	return new CustomEvent(type, { detail, bubbles, cancelable });
-}
-
-/**
- * @typedef {Node & {
- * 	claim_order?: number;
- * 	hydrate_init?: true;
- * 	actual_end_child?: NodeEx;
- * 	childNodes: NodeListOf<NodeEx>;
- * }} NodeEx
- */
-
-/** @typedef {ChildNode & NodeEx} ChildNodeEx */
-
-/** @typedef {NodeEx & { claim_order: number }} NodeEx2 */
-
-/**
- * @typedef {ChildNodeEx[] & {
- * 	claim_info?: {
- * 		last_index: number;
- * 		total_claimed: number;
- * 	};
- * }} ChildNodeArray
- */
-
-let current_component;
-
-/** @returns {void} */
-function set_current_component(component) {
-	current_component = component;
-}
-
-function get_current_component() {
-	if (!current_component) throw new Error('Function called outside component initialization');
-	return current_component;
-}
-
-/**
- * Creates an event dispatcher that can be used to dispatch [component events](/docs#template-syntax-component-directives-on-eventname).
- * Event dispatchers are functions that can take two arguments: `name` and `detail`.
- *
- * Component events created with `createEventDispatcher` create a
- * [CustomEvent](https://developer.mozilla.org/en-US/docs/Web/API/CustomEvent).
- * These events do not [bubble](https://developer.mozilla.org/en-US/docs/Learn/JavaScript/Building_blocks/Events#Event_bubbling_and_capture).
- * The `detail` argument corresponds to the [CustomEvent.detail](https://developer.mozilla.org/en-US/docs/Web/API/CustomEvent/detail)
- * property and can contain any type of data.
- *
- * The event dispatcher can be typed to narrow the allowed event names and the type of the `detail` argument:
- * ```ts
- * const dispatch = createEventDispatcher<{
- *  loaded: never; // does not take a detail argument
- *  change: string; // takes a detail argument of type string, which is required
- *  optional: number | null; // takes an optional detail argument of type number
- * }>();
- * ```
- *
- * https://svelte.dev/docs/svelte#createeventdispatcher
- * @template {Record<string, any>} [EventMap=any]
- * @returns {import('./public.js').EventDispatcher<EventMap>}
- */
-function createEventDispatcher() {
-	const component = get_current_component();
-	return (type, detail, { cancelable = false } = {}) => {
-		const callbacks = component.$$.callbacks[type];
-		if (callbacks) {
-			// TODO are there situations where events could be dispatched
-			// in a server (non-DOM) environment?
-			const event = custom_event(/** @type {string} */ (type), detail, { cancelable });
-			callbacks.slice().forEach((fn) => {
-				fn.call(component, event);
-			});
-			return !event.defaultPrevented;
-		}
-		return true;
-	};
-}
-
-const dirty_components = [];
-const binding_callbacks = [];
-
-let render_callbacks = [];
-
-const flush_callbacks = [];
-
-const resolved_promise = /* @__PURE__ */ Promise.resolve();
-
-let update_scheduled = false;
-
-/** @returns {void} */
-function schedule_update() {
-	if (!update_scheduled) {
-		update_scheduled = true;
-		resolved_promise.then(flush);
-	}
-}
-
-/** @returns {void} */
-function add_render_callback(fn) {
-	render_callbacks.push(fn);
-}
-
-// flush() calls callbacks in this order:
-// 1. All beforeUpdate callbacks, in order: parents before children
-// 2. All bind:this callbacks, in reverse order: children before parents.
-// 3. All afterUpdate callbacks, in order: parents before children. EXCEPT
-//    for afterUpdates called during the initial onMount, which are called in
-//    reverse order: children before parents.
-// Since callbacks might update component values, which could trigger another
-// call to flush(), the following steps guard against this:
-// 1. During beforeUpdate, any updated components will be added to the
-//    dirty_components array and will cause a reentrant call to flush(). Because
-//    the flush index is kept outside the function, the reentrant call will pick
-//    up where the earlier call left off and go through all dirty components. The
-//    current_component value is saved and restored so that the reentrant call will
-//    not interfere with the "parent" flush() call.
-// 2. bind:this callbacks cannot trigger new flush() calls.
-// 3. During afterUpdate, any updated components will NOT have their afterUpdate
-//    callback called a second time; the seen_callbacks set, outside the flush()
-//    function, guarantees this behavior.
-const seen_callbacks = new Set();
-
-let flushidx = 0; // Do *not* move this inside the flush() function
-
-/** @returns {void} */
-function flush() {
-	// Do not reenter flush while dirty components are updated, as this can
-	// result in an infinite loop. Instead, let the inner flush handle it.
-	// Reentrancy is ok afterwards for bindings etc.
-	if (flushidx !== 0) {
-		return;
-	}
-	const saved_component = current_component;
-	do {
-		// first, call beforeUpdate functions
-		// and update components
-		try {
-			while (flushidx < dirty_components.length) {
-				const component = dirty_components[flushidx];
-				flushidx++;
-				set_current_component(component);
-				update(component.$$);
-			}
-		} catch (e) {
-			// reset dirty state to not end up in a deadlocked state and then rethrow
-			dirty_components.length = 0;
-			flushidx = 0;
-			throw e;
-		}
-		set_current_component(null);
-		dirty_components.length = 0;
-		flushidx = 0;
-		while (binding_callbacks.length) binding_callbacks.pop()();
-		// then, once components are updated, call
-		// afterUpdate functions. This may cause
-		// subsequent updates...
-		for (let i = 0; i < render_callbacks.length; i += 1) {
-			const callback = render_callbacks[i];
-			if (!seen_callbacks.has(callback)) {
-				// ...so guard against infinite loops
-				seen_callbacks.add(callback);
-				callback();
-			}
-		}
-		render_callbacks.length = 0;
-	} while (dirty_components.length);
-	while (flush_callbacks.length) {
-		flush_callbacks.pop()();
-	}
-	update_scheduled = false;
-	seen_callbacks.clear();
-	set_current_component(saved_component);
-}
-
-/** @returns {void} */
-function update($$) {
-	if ($$.fragment !== null) {
-		$$.update();
-		run_all($$.before_update);
-		const dirty = $$.dirty;
-		$$.dirty = [-1];
-		$$.fragment && $$.fragment.p($$.ctx, dirty);
-		$$.after_update.forEach(add_render_callback);
-	}
-}
-
-/**
- * Useful for example to execute remaining `afterUpdate` callbacks before executing `destroy`.
- * @param {Function[]} fns
- * @returns {void}
- */
-function flush_render_callbacks(fns) {
-	const filtered = [];
-	const targets = [];
-	render_callbacks.forEach((c) => (fns.indexOf(c) === -1 ? filtered.push(c) : targets.push(c)));
-	targets.forEach((c) => c());
-	render_callbacks = filtered;
-}
-
-const outroing = new Set();
-
-/**
- * @type {Outro}
- */
-let outros;
-
-/**
- * @param {import('./private.js').Fragment} block
- * @param {0 | 1} [local]
- * @returns {void}
- */
-function transition_in(block, local) {
-	if (block && block.i) {
-		outroing.delete(block);
-		block.i(local);
-	}
-}
-
-/**
- * @param {import('./private.js').Fragment} block
- * @param {0 | 1} local
- * @param {0 | 1} [detach]
- * @param {() => void} [callback]
- * @returns {void}
- */
-function transition_out(block, local, detach, callback) {
-	if (block && block.o) {
-		if (outroing.has(block)) return;
-		outroing.add(block);
-		outros.c.push(() => {
-			outroing.delete(block);
-			if (callback) {
-				if (detach) block.d(1);
-				callback();
-			}
-		});
-		block.o(local);
-	} else if (callback) {
-		callback();
-	}
-}
-
-/** @typedef {1} INTRO */
-/** @typedef {0} OUTRO */
-/** @typedef {{ direction: 'in' | 'out' | 'both' }} TransitionOptions */
-/** @typedef {(node: Element, params: any, options: TransitionOptions) => import('../transition/public.js').TransitionConfig} TransitionFn */
-
-/**
- * @typedef {Object} Outro
- * @property {number} r
- * @property {Function[]} c
- * @property {Object} p
- */
-
-/**
- * @typedef {Object} PendingProgram
- * @property {number} start
- * @property {INTRO|OUTRO} b
- * @property {Outro} [group]
- */
-
-/**
- * @typedef {Object} Program
- * @property {number} a
- * @property {INTRO|OUTRO} b
- * @property {1|-1} d
- * @property {number} duration
- * @property {number} start
- * @property {number} end
- * @property {Outro} [group]
- */
-
-/** @returns {void} */
-function mount_component(component, target, anchor) {
-	const { fragment, after_update } = component.$$;
-	fragment && fragment.m(target, anchor);
-	// onMount happens before the initial afterUpdate
-	add_render_callback(() => {
-		const new_on_destroy = component.$$.on_mount.map(run).filter(is_function);
-		// if the component was destroyed immediately
-		// it will update the `$$.on_destroy` reference to `null`.
-		// the destructured on_destroy may still reference to the old array
-		if (component.$$.on_destroy) {
-			component.$$.on_destroy.push(...new_on_destroy);
-		} else {
-			// Edge case - component was destroyed immediately,
-			// most likely as a result of a binding initialising
-			run_all(new_on_destroy);
-		}
-		component.$$.on_mount = [];
-	});
-	after_update.forEach(add_render_callback);
-}
-
-/** @returns {void} */
-function destroy_component(component, detaching) {
-	const $$ = component.$$;
-	if ($$.fragment !== null) {
-		flush_render_callbacks($$.after_update);
-		run_all($$.on_destroy);
-		$$.fragment && $$.fragment.d(detaching);
-		// TODO null out other refs, including component.$$ (but need to
-		// preserve final state?)
-		$$.on_destroy = $$.fragment = null;
-		$$.ctx = [];
-	}
-}
-
-/** @returns {void} */
-function make_dirty(component, i) {
-	if (component.$$.dirty[0] === -1) {
-		dirty_components.push(component);
-		schedule_update();
-		component.$$.dirty.fill(0);
-	}
-	component.$$.dirty[(i / 31) | 0] |= 1 << i % 31;
-}
-
-/** @returns {void} */
-function init(
-	component,
-	options,
-	instance,
-	create_fragment,
-	not_equal,
-	props,
-	append_styles,
-	dirty = [-1]
-) {
-	const parent_component = current_component;
-	set_current_component(component);
-	/** @type {import('./private.js').T$$} */
-	const $$ = (component.$$ = {
-		fragment: null,
-		ctx: [],
-		// state
-		props,
-		update: noop,
-		not_equal,
-		bound: blank_object(),
-		// lifecycle
-		on_mount: [],
-		on_destroy: [],
-		on_disconnect: [],
-		before_update: [],
-		after_update: [],
-		context: new Map(options.context || (parent_component ? parent_component.$$.context : [])),
-		// everything else
-		callbacks: blank_object(),
-		dirty,
-		skip_bound: false,
-		root: options.target || parent_component.$$.root
-	});
-	append_styles && append_styles($$.root);
-	let ready = false;
-	$$.ctx = instance
-		? instance(component, options.props || {}, (i, ret, ...rest) => {
-				const value = rest.length ? rest[0] : ret;
-				if ($$.ctx && not_equal($$.ctx[i], ($$.ctx[i] = value))) {
-					if (!$$.skip_bound && $$.bound[i]) $$.bound[i](value);
-					if (ready) make_dirty(component, i);
-				}
-				return ret;
-		  })
-		: [];
-	$$.update();
-	ready = true;
-	run_all($$.before_update);
-	// `false` as a special case of no DOM component
-	$$.fragment = create_fragment ? create_fragment($$.ctx) : false;
-	if (options.target) {
-		if (options.hydrate) {
-			const nodes = children(options.target);
-			// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-			$$.fragment && $$.fragment.l(nodes);
-			nodes.forEach(detach);
-		} else {
-			// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-			$$.fragment && $$.fragment.c();
-		}
-		if (options.intro) transition_in(component.$$.fragment);
-		mount_component(component, options.target, options.anchor);
-		flush();
-	}
-	set_current_component(parent_component);
-}
-
-/**
- * Base class for Svelte components. Used when dev=false.
- *
- * @template {Record<string, any>} [Props=any]
- * @template {Record<string, any>} [Events=any]
- */
-class SvelteComponent {
-	/**
-	 * ### PRIVATE API
-	 *
-	 * Do not use, may change at any time
-	 *
-	 * @type {any}
-	 */
-	$$ = undefined;
-	/**
-	 * ### PRIVATE API
-	 *
-	 * Do not use, may change at any time
-	 *
-	 * @type {any}
-	 */
-	$$set = undefined;
-
-	/** @returns {void} */
-	$destroy() {
-		destroy_component(this, 1);
-		this.$destroy = noop;
-	}
-
-	/**
-	 * @template {Extract<keyof Events, string>} K
-	 * @param {K} type
-	 * @param {((e: Events[K]) => void) | null | undefined} callback
-	 * @returns {() => void}
-	 */
-	$on(type, callback) {
-		if (!is_function(callback)) {
-			return noop;
-		}
-		const callbacks = this.$$.callbacks[type] || (this.$$.callbacks[type] = []);
-		callbacks.push(callback);
-		return () => {
-			const index = callbacks.indexOf(callback);
-			if (index !== -1) callbacks.splice(index, 1);
-		};
-	}
-
-	/**
-	 * @param {Partial<Props>} props
-	 * @returns {void}
-	 */
-	$set(props) {
-		if (this.$$set && !is_empty(props)) {
-			this.$$.skip_bound = true;
-			this.$$set(props);
-			this.$$.skip_bound = false;
-		}
-	}
-}
-
-/**
- * @typedef {Object} CustomElementPropDefinition
- * @property {string} [attribute]
- * @property {boolean} [reflect]
- * @property {'String'|'Boolean'|'Number'|'Array'|'Object'} [type]
- */
-
-// generated during release, do not modify
-const PUBLIC_VERSION = '4';
-
-if (typeof window !== 'undefined')
-	// @ts-ignore
-	(window.__svelte || (window.__svelte = { v: new Set() })).v.add(PUBLIC_VERSION);
-
-/* src/IntersectionObserver.svelte generated by Svelte v4.1.0 */
-
-const get_default_slot_changes = dirty => ({
-	intersecting: dirty & /*intersecting*/ 1,
-	entry: dirty & /*entry*/ 2,
-	observer: dirty & /*observer*/ 4
-});
-
-const get_default_slot_context = ctx => ({
-	intersecting: /*intersecting*/ ctx[0],
-	entry: /*entry*/ ctx[1],
-	observer: /*observer*/ ctx[2]
-});
-
-function create_fragment(ctx) {
-	let current;
-	const default_slot_template = /*#slots*/ ctx[9].default;
-	const default_slot = create_slot(default_slot_template, ctx, /*$$scope*/ ctx[8], get_default_slot_context);
-
-	return {
-		c() {
-			if (default_slot) default_slot.c();
-		},
-		m(target, anchor) {
-			if (default_slot) {
-				default_slot.m(target, anchor);
-			}
-
-			current = true;
-		},
-		p(ctx, [dirty]) {
-			if (default_slot) {
-				if (default_slot.p && (!current || dirty & /*$$scope, intersecting, entry, observer*/ 263)) {
-					update_slot_base(
-						default_slot,
-						default_slot_template,
-						ctx,
-						/*$$scope*/ ctx[8],
-						!current
-						? get_all_dirty_from_scope(/*$$scope*/ ctx[8])
-						: get_slot_changes(default_slot_template, /*$$scope*/ ctx[8], dirty, get_default_slot_changes),
-						get_default_slot_context
-					);
-				}
-			}
-		},
-		i(local) {
-			if (current) return;
-			transition_in(default_slot, local);
-			current = true;
-		},
-		o(local) {
-			transition_out(default_slot, local);
-			current = false;
-		},
-		d(detaching) {
-			if (default_slot) default_slot.d(detaching);
-		}
-	};
-}
-
-function instance($$self, $$props, $$invalidate) {
-	let { $$slots: slots = {}, $$scope } = $$props;
-	let { element = null } = $$props;
-	let { once = false } = $$props;
-	let { intersecting = false } = $$props;
-	let { root = null } = $$props;
-	let { rootMargin = "0px" } = $$props;
-	let { threshold = 0 } = $$props;
-	let { entry = null } = $$props;
-	let { observer = null } = $$props;
-	createEventDispatcher();
-
-	$$self.$$set = $$props => {
-		if ('element' in $$props) $$invalidate(3, element = $$props.element);
-		if ('once' in $$props) $$invalidate(4, once = $$props.once);
-		if ('intersecting' in $$props) $$invalidate(0, intersecting = $$props.intersecting);
-		if ('root' in $$props) $$invalidate(5, root = $$props.root);
-		if ('rootMargin' in $$props) $$invalidate(6, rootMargin = $$props.rootMargin);
-		if ('threshold' in $$props) $$invalidate(7, threshold = $$props.threshold);
-		if ('entry' in $$props) $$invalidate(1, entry = $$props.entry);
-		if ('observer' in $$props) $$invalidate(2, observer = $$props.observer);
-		if ('$$scope' in $$props) $$invalidate(8, $$scope = $$props.$$scope);
-	};
-
-	return [
-		intersecting,
-		entry,
-		observer,
-		element,
-		once,
-		root,
-		rootMargin,
-		threshold,
-		$$scope,
-		slots
-	];
-}
-
-class IntersectionObserver_1 extends SvelteComponent {
-	constructor(options) {
-		super();
-
-		init(this, options, instance, create_fragment, safe_not_equal, {
-			element: 3,
-			once: 4,
-			intersecting: 0,
-			root: 5,
-			rootMargin: 6,
-			threshold: 7,
-			entry: 1,
-			observer: 2
-		});
-	}
-}
-
-export { IntersectionObserver_1 as default };

package/src/index.js

@@ -1,3 +0,0 @@
-import IntersectionObserver from "./IntersectionObserver.svelte";
-
-export default IntersectionObserver;