@tanstack/svelte-table/build/lib/index.mjs

Headless UI for building powerful tables & datagrids for Svelte.

/**
   * svelte-table
   *
   * Copyright (c) TanStack
   *
   * This source code is licensed under the MIT license found in the
   * LICENSE.md file in the root directory of this source tree.
   *
   * @license MIT
   */
import { createTable } from '@tanstack/table-core';
export * from '@tanstack/table-core';
import { SvelteComponent, init, safe_not_equal, text, claim_text, insert_hydration, set_data, noop, detach, create_ssr_component, escape, validate_component, create_component, claim_component, mount_component, transition_in, transition_out, destroy_component } from 'svelte/internal';
import 'svelte/internal/disclose-version';
import { readable, get, writable, derived } from 'svelte/store';

/* src/placeholder.svelte generated by Svelte v4.2.18 */

function create_fragment$1(ctx) {
	let t;

	return {
		c() {
			t = text(/*content*/ ctx[0]);
		},
		l(nodes) {
			t = claim_text(nodes, /*content*/ ctx[0]);
		},
		m(target, anchor) {
			insert_hydration(target, t, anchor);
		},
		p(ctx, [dirty]) {
			if (dirty & /*content*/ 1) set_data(t, /*content*/ ctx[0]);
		},
		i: noop,
		o: noop,
		d(detaching) {
			if (detaching) {
				detach(t);
			}
		}
	};
}

function instance($$self, $$props, $$invalidate) {
	let { content } = $$props;

	$$self.$$set = $$props => {
		if ('content' in $$props) $$invalidate(0, content = $$props.content);
	};

	return [content];
}

let Placeholder$1 = class Placeholder extends SvelteComponent {
	constructor(options) {
		super();
		init(this, options, instance, create_fragment$1, safe_not_equal, { content: 0 });
	}
};

const PlaceholderServer = create_ssr_component(($$result, $$props, $$bindings, slots) => {
  return `${escape($$props.content)}`;
});
var Placeholder = typeof document === 'undefined' ? PlaceholderServer : Placeholder$1;

function create_fragment(ctx, Comp, props) {
  let c;
  let current;
  c = new Comp({
    props,
    $$inline: true
  });
  return {
    c() {
      create_component(c.$$.fragment);
    },
    l(nodes) {
      claim_component(c.$$.fragment, nodes);
    },
    m(target, anchor) {
      // @ts-ignore
      mount_component(c, target, anchor);
      current = true;
    },
    p: noop,
    i(local) {
      if (current) return;
      transition_in(c.$$.fragment, local);
      current = true;
    },
    o(local) {
      transition_out(c.$$.fragment, local);
      current = false;
    },
    d(detaching) {
      destroy_component(c, detaching);
    }
  };
}
function renderClient(Comp, props) {
  return class WrapperComp extends SvelteComponent {
    constructor(options) {
      super();
      init(this, options, null, ctx => create_fragment(ctx, Comp, props), safe_not_equal, {}, undefined);
    }
  };
}
function renderServer(Comp, props) {
  const WrapperComp = create_ssr_component(($$result, $$props, $$bindings, slots) => {
    return `${validate_component(Comp, 'TableComponent').$$render($$result, props, {}, {})}`;
  });
  return WrapperComp;
}
const renderComponent = typeof window === 'undefined' ? renderServer : renderClient;

function isSvelteServerComponent(component) {
  return typeof component === 'object' && typeof component.$$render === 'function' && typeof component.render === 'function';
}
function isSvelteClientComponent(component) {
  var _component$name, _component$name2;
  let isHMR = ('__SVELTE_HMR' in window);
  return component.prototype instanceof SvelteComponent || isHMR && ((_component$name = component.name) == null ? void 0 : _component$name.startsWith('Proxy<')) && ((_component$name2 = component.name) == null ? void 0 : _component$name2.endsWith('>'));
}
function isSvelteComponent(component) {
  if (typeof document === 'undefined') {
    return isSvelteServerComponent(component);
  } else {
    return isSvelteClientComponent(component);
  }
}
function wrapInPlaceholder(content) {
  return renderComponent(Placeholder, {
    content
  });
}
function flexRender(component, props) {
  if (!component) return null;
  if (isSvelteComponent(component)) {
    return renderComponent(component, props);
  }
  if (typeof component === 'function') {
    const result = component(props);
    if (result === null || result === undefined) return null;
    if (isSvelteComponent(result)) {
      return renderComponent(result, props);
    }
    return wrapInPlaceholder(result);
  }
  return wrapInPlaceholder(component);
}
function createSvelteTable(options) {
  let optionsStore;
  if ('subscribe' in options) {
    optionsStore = options;
  } else {
    optionsStore = readable(options);
  }
  let resolvedOptions = {
    state: {},
    // Dummy state
    onStateChange: () => {},
    // noop
    renderFallbackValue: null,
    ...get(optionsStore)
  };
  let table = createTable(resolvedOptions);
  let stateStore = writable( /** @type {number} */table.initialState);
  // combine stores
  let stateOptionsStore = derived([stateStore, optionsStore], s => s);
  const tableReadable = readable(table, function start(set) {
    const unsubscribe = stateOptionsStore.subscribe(_ref => {
      let [state, options] = _ref;
      table.setOptions(prev => {
        return {
          ...prev,
          ...options,
          state: {
            ...state,
            ...options.state
          },
          // Similarly, we'll maintain both our internal state and any user-provided
          // state.
          onStateChange: updater => {
            if (updater instanceof Function) {
              stateStore.update(updater);
            } else {
              stateStore.set(updater);
            }
            resolvedOptions.onStateChange == null || resolvedOptions.onStateChange(updater);
          }
        };
      });

      // it didn't seem to rerender without setting the table
      set(table);
    });
    return function stop() {
      unsubscribe();
    };
  });
  return tableReadable;
}

export { createSvelteTable, flexRender, renderComponent };
//# sourceMappingURL=index.mjs.map