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

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
   */
'use strict';

var tableCore = require('@tanstack/table-core');
var placeholder = require('./placeholder.js');
var internal = require('svelte/internal');
var store = require('svelte/store');
var renderComponent = require('./render-component.js');

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 internal.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.renderComponent(placeholder.default, {
    content
  });
}
function flexRender(component, props) {
  if (!component) return null;
  if (isSvelteComponent(component)) {
    return renderComponent.renderComponent(component, props);
  }
  if (typeof component === 'function') {
    const result = component(props);
    if (result === null || result === undefined) return null;
    if (isSvelteComponent(result)) {
      return renderComponent.renderComponent(result, props);
    }
    return wrapInPlaceholder(result);
  }
  return wrapInPlaceholder(component);
}
function createSvelteTable(options) {
  let optionsStore;
  if ('subscribe' in options) {
    optionsStore = options;
  } else {
    optionsStore = store.readable(options);
  }
  let resolvedOptions = {
    state: {},
    // Dummy state
    onStateChange: () => {},
    // noop
    renderFallbackValue: null,
    ...store.get(optionsStore)
  };
  let table = tableCore.createTable(resolvedOptions);
  let stateStore = store.writable( /** @type {number} */table.initialState);
  // combine stores
  let stateOptionsStore = store.derived([stateStore, optionsStore], s => s);
  const tableReadable = store.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;
}

exports.renderComponent = renderComponent.renderComponent;
exports.createSvelteTable = createSvelteTable;
exports.flexRender = flexRender;
Object.keys(tableCore).forEach(function (k) {
  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
    enumerable: true,
    get: function () { return tableCore[k]; }
  });
});
//# sourceMappingURL=index.js.map