@tanstack/ember-table 9.0.0-beta.0

package/dist/index.js

@@ -0,0 +1,286 @@
+import { constructTable, createColumnHelper } from '@tanstack/table-core';
+export * from '@tanstack/table-core';
+import { untrack } from '@glimmer/validator';
+import { tracked, cached } from '@glimmer/tracking';
+import { g, i, n } from 'decorator-transforms/runtime-esm';
+export { F as FlexRenderCell, a as FlexRenderComponentConfig, b as FlexRenderFooter, c as FlexRenderHeader, f as flexRenderComponent } from './FlexRender-fkWv7pUy.js';
+export { flexRender } from '@tanstack/table-core/flex-render';
+
+function subscribeNoEffect() {
+  return null;
+}
+
+/**
+ * Ember-native signal implementation.
+ * In future ember >7.3 `tracked` will be available by itself
+ * so the class wrapper will not be needed for those versions
+ */
+class Signal {
+  static {
+    g(this.prototype, "_value", [tracked]);
+  }
+  #_value = (i(this, "_value"), void 0);
+  #options;
+
+  // Ember reads are tag-tracked; this observer list exists for the plain-JS
+  // subscribers core wires up (external-atom sync in constructTable, the
+  // inspector), which have no access to framework tracking.
+  #listeners = new Set();
+  constructor(value, options) {
+    this._value = value;
+    this.#options = options;
+  }
+  subscribe(listenerOrObserver) {
+    const listener = typeof listenerOrObserver === 'function' ? listenerOrObserver : listenerOrObserver.next;
+    if (!listener) {
+      return {
+        unsubscribe: () => {}
+      };
+    }
+    this.#listeners.add(listener);
+    return {
+      unsubscribe: () => this.#listeners.delete(listener)
+    };
+  }
+  get() {
+    return this.value;
+  }
+  set(value) {
+    if (typeof value === 'function') {
+      return this.update(value);
+    }
+    this.value = value;
+  }
+  get value() {
+    return this._value;
+  }
+  set value(next) {
+    const prev = untrack(() => this._value);
+    const isEqual = this.#options?.compare ? this.#options.compare(prev, next) : prev === next;
+    if (isEqual) {
+      return;
+    }
+    this._value = next;
+    for (const listener of this.#listeners) {
+      listener(next);
+    }
+  }
+  update(fn) {
+    const original = untrack(() => this._value);
+    this.value = fn(original);
+  }
+}
+class ComputedSignal {
+  #compute;
+  constructor(compute) {
+    this.#compute = compute;
+  }
+  get() {
+    return this.value;
+  }
+  subscribe = subscribeNoEffect;
+  get value() {
+    return this.#compute();
+  }
+  static {
+    n(this.prototype, "value", [cached]);
+  }
+}
+function signal(value, options) {
+  return new Signal(value, options);
+}
+
+/**
+ * Creates an Ember-native writable atom, satisfying the `@tanstack/store`
+ * `Atom` contract so it can be passed to `options.atoms`. Because it is backed
+ * by a `@tracked` Signal, reading `atom.get()` directly in a template or
+ * getter is reactive — unlike a foreign `@tanstack/store` atom, whose reads
+ * create no Glimmer tag dependency.
+ *
+ * Takes a plain initial value only; there is no derived/function overload.
+ */
+function createAtom(initialValue, options) {
+  return signal(initialValue, options);
+}
+function computed(fn) {
+  return new ComputedSignal(fn);
+}
+
+function emberReactivity() {
+  const subscriptions = new Set();
+  return {
+    createOptionsStore: true,
+    wrapExternalAtoms: true,
+    // timing is not important, but the main thing is that the work does *not*
+    // happen during the render phase.
+    schedule: fn => queueMicrotask(() => fn()),
+    batch: fn => fn(),
+    untrack,
+    // @cached
+    createReadonlyAtom: fn => {
+      return computed(fn);
+    },
+    // @tracked
+    createWritableAtom: (value, options) => {
+      return signal(value, options);
+    },
+    // Not for the ember integration, but for the tanstack inspector
+    addSubscription: subscription => {
+      subscriptions.add(subscription);
+    },
+    unmount: () => {
+      subscriptions.forEach(s => s.unsubscribe());
+      subscriptions.clear();
+    }
+  };
+}
+
+// Internal table slots used by the pull-based options/state wiring below.
+// `Table_Internal` is not exported from the table-core build, so the shape is
+// declared structurally here.
+
+function useTable(getOptions) {
+  const reactivity = emberReactivity();
+
+  // Creates reactive read only signal for options
+  const userOptions = computed(getOptions);
+
+  // Untracked to prevent possible "set on same computation as read" errors in Ember.
+  const initialOptions = untrack(() => userOptions.get());
+  const table = constructTable({
+    ...initialOptions,
+    features: {
+      coreReactivityFeature: reactivity,
+      ...initialOptions.features
+    },
+    mergeOptions: (defaultOptions, newOptions) => ({
+      ...defaultOptions,
+      ...newOptions
+    })
+  });
+  const optionsStore = table.optionsStore;
+  const liveOptions = computed(() => {
+    const stored = optionsStore.get();
+    return {
+      ...stored,
+      ...userOptions.get(),
+      // stored options carry construct-time normalization (the reactivity
+      // feature, wrapped external atoms) that must win over the raw user
+      // options.
+      features: stored.features,
+      atoms: stored.atoms
+    };
+  });
+
+  /**
+   * This is to get around core table not using lazy access so we need to re-wrap
+   *
+   * Similar to other reactive signal frameworks (solid, angular, svelte)
+   */
+  Object.defineProperty(table, 'options', {
+    configurable: true,
+    enumerable: true,
+    get: () => liveOptions.get(),
+    set: value => {
+      optionsStore.set(() => value);
+    }
+  });
+  const atoms = table.atoms;
+  const stateKeys = Object.keys(table.baseAtoms);
+  for (const key of stateKeys) {
+    const baseAtom = table.baseAtoms[key];
+
+    /**
+     * Original atoms could cause effects for top level properties
+     *
+     * Core table should migrate to pure derived data which would boost render
+     * performance for both signal and non-signal frameworks.
+     */
+    atoms[key] = reactivity.createReadonlyAtom(() => {
+      const externalAtom = table.options.atoms?.[key];
+      if (externalAtom) {
+        return externalAtom.get();
+      }
+      const stateSlice = table.options.state?.[key];
+      if (stateSlice !== undefined) {
+        return stateSlice;
+      }
+      return baseAtom.get();
+    }, {
+      debugName: `table/atoms/${key}`
+    });
+  }
+  const stateProxy = new Proxy({}, {
+    get: (_target, key) => typeof key === 'string' ? atoms[key]?.get() : undefined,
+    has: (_target, key) => typeof key === 'string' && stateKeys.includes(key),
+    ownKeys: () => stateKeys,
+    getOwnPropertyDescriptor: (_target, key) => typeof key === 'string' && stateKeys.includes(key) ? {
+      enumerable: true,
+      configurable: true,
+      value: atoms[key].get()
+    } : undefined
+  })
+
+  /**
+   * Store is reasigned to point to proxy object to allow individual state slices to be independently reactive.
+   *
+   * Type cast is needed because we are setting during construction
+   * Table store is readonly after first initialization.
+   */;
+  table.store = {
+    get: () => stateProxy,
+    get state() {
+      return stateProxy;
+    },
+    subscribe: subscribeNoEffect
+  };
+  return table;
+}
+
+/**
+ * Bundles a feature set and shared default options once so every table in your
+ * app can be created without repeating them. Returns a typed column helper
+ * factory and a `createAppTable` that wraps {@link useTable}.
+ *
+ * Unlike the React adapter's hook, this does not pre-bind cell/header
+ * components onto the table; render with the `FlexRenderCell`,
+ * `FlexRenderHeader`, and `FlexRenderFooter` components as usual.
+ *
+ * @example
+ * ```ts
+ * const { createAppTable, createAppColumnHelper } = createTableHook({
+ *   features: tableFeatures({ rowSortingFeature, sortedRowModel: createSortedRowModel(), sortFns }),
+ * })
+ *
+ * const columnHelper = createAppColumnHelper<Person>()
+ * const columns = columnHelper.columns([...])
+ *
+ * // inside a Glimmer component; options stay a thunk so tracked reads are reactive
+ * table = createAppTable(() => ({ columns, data: this.data }))
+ * ```
+ */
+function createTableHook({
+  ...defaultTableOptions
+}) {
+  function createAppColumnHelper() {
+    return createColumnHelper();
+  }
+  function createAppTable(getTableOptions) {
+    // Keep options a thunk: the merge runs inside `useTable`'s options thunk,
+    // so tracked properties read in `getTableOptions` stay reactive. Per-table
+    // options take precedence over the shared defaults (except `features`,
+    // which only the hook provides).
+    return useTable(() => ({
+      ...defaultTableOptions,
+      ...getTableOptions()
+    }));
+  }
+  return {
+    appFeatures: defaultTableOptions.features,
+    createAppColumnHelper,
+    createAppTable
+  };
+}
+
+export { ComputedSignal, Signal, computed, createAtom, createTableHook, emberReactivity, signal, useTable };
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../src/signal.ts","../src/reactivity.ts","../src/use-table.ts","../src/create-table-hook.ts"],"sourcesContent":["import type { Atom, AtomOptions, Observer, Subscription } from '@tanstack/store'\n\nimport { tracked, cached } from '@glimmer/tracking'\nimport { untrack } from '@glimmer/validator'\n\nexport function subscribeNoEffect(): Subscription {\n  return null as unknown as Subscription\n}\n\n/**\n * Ember-native signal implementation.\n * In future ember >7.3 `tracked` will be available by itself\n * so the class wrapper will not be needed for those versions\n */\nexport class Signal<T> {\n  @tracked _value\n\n  #options: AtomOptions<T> | undefined\n\n  // Ember reads are tag-tracked; this observer list exists for the plain-JS\n  // subscribers core wires up (external-atom sync in constructTable, the\n  // inspector), which have no access to framework tracking.\n  #listeners = new Set<(value: T) => void>()\n\n  constructor(value: T, options: AtomOptions<T> | undefined) {\n    this._value = value\n    this.#options = options\n  }\n\n  subscribe(\n    listenerOrObserver: Observer<T> | ((value: T) => void),\n  ): Subscription {\n    const listener =\n      typeof listenerOrObserver === 'function'\n        ? listenerOrObserver\n        : listenerOrObserver.next\n\n    if (!listener) {\n      return { unsubscribe: () => {} }\n    }\n\n    this.#listeners.add(listener)\n    return { unsubscribe: () => this.#listeners.delete(listener) }\n  }\n\n  get() {\n    return this.value\n  }\n  set(value: T | ((prev: T) => T)) {\n    if (typeof value === 'function') {\n      return this.update(value as unknown as (prev: T) => T)\n    }\n\n    this.value = value\n  }\n\n  get value() {\n    return this._value\n  }\n\n  set value(next: T) {\n    const prev = untrack(() => this._value)\n\n    const isEqual = this.#options?.compare\n      ? this.#options.compare(prev, next)\n      : prev === next\n    if (isEqual) {\n      return\n    }\n\n    this._value = next\n\n    for (const listener of this.#listeners) {\n      listener(next)\n    }\n  }\n\n  update(fn: (value: T) => T) {\n    const original = untrack(() => this._value)\n\n    this.value = fn(original)\n  }\n}\n\nexport class ComputedSignal<T> {\n  #compute\n\n  constructor(compute: () => T) {\n    this.#compute = compute\n  }\n\n  get() {\n    return this.value\n  }\n\n  subscribe = subscribeNoEffect\n\n  @cached\n  get value() {\n    return this.#compute()\n  }\n}\n\nexport function signal<T>(value: T, options: AtomOptions<T> | undefined) {\n  return new Signal(value, options)\n}\n\n/**\n * Creates an Ember-native writable atom, satisfying the `@tanstack/store`\n * `Atom` contract so it can be passed to `options.atoms`. Because it is backed\n * by a `@tracked` Signal, reading `atom.get()` directly in a template or\n * getter is reactive — unlike a foreign `@tanstack/store` atom, whose reads\n * create no Glimmer tag dependency.\n *\n * Takes a plain initial value only; there is no derived/function overload.\n */\nexport function createAtom<T>(\n  initialValue: T,\n  options?: AtomOptions<T>,\n): Atom<T> {\n  return signal(initialValue, options)\n}\n\nexport function computed<T>(fn: () => T) {\n  return new ComputedSignal(fn)\n}\n","import type { Subscription } from '@tanstack/store'\nimport type {\n  TableAtomOptions,\n  TableReactivityBindings,\n} from '@tanstack/table-core/reactivity'\n\nimport { untrack } from '@glimmer/validator'\nimport { computed, signal } from './signal.ts'\n\nexport function emberReactivity(): TableReactivityBindings {\n  const subscriptions = new Set<Subscription>()\n\n  return {\n    createOptionsStore: true,\n    wrapExternalAtoms: true,\n\n    // timing is not important, but the main thing is that the work does *not*\n    // happen during the render phase.\n    schedule: (fn) => queueMicrotask(() => fn()),\n    batch: (fn) => fn(),\n    untrack,\n    // @cached\n    createReadonlyAtom: <T>(fn: () => T) => {\n      return computed(fn)\n    },\n    // @tracked\n    createWritableAtom: <T>(value: T, options?: TableAtomOptions<T>) => {\n      return signal(value, options)\n    },\n    // Not for the ember integration, but for the tanstack inspector\n    addSubscription: (subscription) => {\n      subscriptions.add(subscription)\n    },\n    unmount: () => {\n      subscriptions.forEach((s) => s.unsubscribe())\n      subscriptions.clear()\n    },\n  }\n}\n","import { constructTable } from '@tanstack/table-core'\nimport { untrack } from '@glimmer/validator'\nimport { emberReactivity } from './reactivity.ts'\nimport { computed, subscribeNoEffect } from './signal.ts'\nimport type {\n  RowData,\n  Table,\n  TableFeatures,\n  TableOptions,\n  TableState,\n} from '@tanstack/table-core'\nimport type { Atom, ReadonlyAtom, ReadonlyStore } from '@tanstack/store'\n\n// Internal table slots used by the pull-based options/state wiring below.\n// `Table_Internal` is not exported from the table-core build, so the shape is\n// declared structurally here.\ninterface TableInternals<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n> {\n  optionsStore?: {\n    get(): TableOptions<TFeatures, TData>\n    set(value: () => TableOptions<TFeatures, TData>): void\n  }\n  baseAtoms: Record<string, { get(): unknown }>\n  atoms: Record<string, unknown>\n}\n\nexport function useTable<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(getOptions: () => TableOptions<TFeatures, TData>): Table<TFeatures, TData> {\n  const reactivity = emberReactivity()\n\n  // Creates reactive read only signal for options\n  const userOptions = computed(getOptions)\n\n  // Untracked to prevent possible \"set on same computation as read\" errors in Ember.\n  const initialOptions = untrack(() => userOptions.get())\n\n  const table = constructTable<TFeatures, TData>({\n    ...initialOptions,\n    features: {\n      coreReactivityFeature: reactivity,\n      ...initialOptions.features,\n    },\n    mergeOptions: (\n      defaultOptions: TableOptions<TFeatures, TData>,\n      newOptions: Partial<TableOptions<TFeatures, TData>>,\n    ) => ({\n      ...defaultOptions,\n      ...newOptions,\n    }),\n  }) as Table<TFeatures, TData> & TableInternals<TFeatures, TData>\n\n  const optionsStore = table.optionsStore!\n\n  const liveOptions = computed(() => {\n    const stored = optionsStore.get()\n    return {\n      ...stored,\n      ...userOptions.get(),\n      // stored options carry construct-time normalization (the reactivity\n      // feature, wrapped external atoms) that must win over the raw user\n      // options.\n      features: stored.features,\n      atoms: stored.atoms,\n    }\n  })\n\n  /**\n   * This is to get around core table not using lazy access so we need to re-wrap\n   *\n   * Similar to other reactive signal frameworks (solid, angular, svelte)\n   */\n  Object.defineProperty(table, 'options', {\n    configurable: true,\n    enumerable: true,\n    get: () => liveOptions.get(),\n    set: (value: TableOptions<TFeatures, TData>) => {\n      optionsStore.set(() => value)\n    },\n  })\n\n  const atoms: Record<string, ReadonlyAtom<unknown>> = table.atoms\n  const stateKeys = Object.keys(table.baseAtoms)\n\n  for (const key of stateKeys) {\n    const baseAtom = (table.baseAtoms as Record<string, ReadonlyAtom<unknown>>)[\n      key\n    ]!\n\n    /**\n     * Original atoms could cause effects for top level properties\n     *\n     * Core table should migrate to pure derived data which would boost render\n     * performance for both signal and non-signal frameworks.\n     */\n    atoms[key] = reactivity.createReadonlyAtom(\n      () => {\n        const externalAtom = (\n          table.options.atoms as Record<string, Atom<unknown>> | undefined\n        )?.[key]\n        if (externalAtom) {\n          return externalAtom.get()\n        }\n        const stateSlice = (\n          table.options.state as Record<string, unknown> | undefined\n        )?.[key]\n        if (stateSlice !== undefined) {\n          return stateSlice\n        }\n        return baseAtom.get()\n      },\n      { debugName: `table/atoms/${key}` },\n    )\n  }\n\n  const stateProxy: TableState<TFeatures> = new Proxy(\n    {},\n    {\n      get: (_target, key) =>\n        typeof key === 'string' ? atoms[key]?.get() : undefined,\n      has: (_target, key) => typeof key === 'string' && stateKeys.includes(key),\n      ownKeys: () => stateKeys,\n      getOwnPropertyDescriptor: (_target, key) =>\n        typeof key === 'string' && stateKeys.includes(key)\n          ? {\n              enumerable: true,\n              configurable: true,\n              value: atoms[key]!.get(),\n            }\n          : undefined,\n    },\n  ) as TableState<TFeatures>\n\n  /**\n   * Store is reasigned to point to proxy object to allow individual state slices to be independently reactive.\n   *\n   * Type cast is needed because we are setting during construction\n   * Table store is readonly after first initialization.\n   */\n  ;(\n    table as { store: Omit<ReadonlyStore<TableState<TFeatures>>, 'atom'> }\n  ).store = {\n    get: () => stateProxy,\n    get state() {\n      return stateProxy\n    },\n    subscribe: subscribeNoEffect,\n  }\n\n  return table\n}\n","import { createColumnHelper as coreCreateColumnHelper } from '@tanstack/table-core'\nimport { useTable } from './use-table.ts'\nimport type {\n  RowData,\n  Table,\n  TableFeatures,\n  TableOptions,\n} from '@tanstack/table-core'\n\nexport type CreateTableHookOptions<TFeatures extends TableFeatures> = Omit<\n  // `any` (not `RowData`) is intentional and matches the other adapters'\n  // createTableHook: shared defaults are declared before any specific TData is\n  // known, and TData-dependent options like `getRowId` and `meta` are\n  // contravariant in TData, so a narrower type would reject them here.\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  TableOptions<TFeatures, any>,\n  'columns' | 'data' | 'state'\n>\n\nexport type AppEmberTable<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n> = Table<TFeatures, TData>\n\nexport type AppColumnHelper<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n> = ReturnType<typeof coreCreateColumnHelper<TFeatures, TData>>\n\n/**\n * Bundles a feature set and shared default options once so every table in your\n * app can be created without repeating them. Returns a typed column helper\n * factory and a `createAppTable` that wraps {@link useTable}.\n *\n * Unlike the React adapter's hook, this does not pre-bind cell/header\n * components onto the table; render with the `FlexRenderCell`,\n * `FlexRenderHeader`, and `FlexRenderFooter` components as usual.\n *\n * @example\n * ```ts\n * const { createAppTable, createAppColumnHelper } = createTableHook({\n *   features: tableFeatures({ rowSortingFeature, sortedRowModel: createSortedRowModel(), sortFns }),\n * })\n *\n * const columnHelper = createAppColumnHelper<Person>()\n * const columns = columnHelper.columns([...])\n *\n * // inside a Glimmer component; options stay a thunk so tracked reads are reactive\n * table = createAppTable(() => ({ columns, data: this.data }))\n * ```\n */\nexport function createTableHook<TFeatures extends TableFeatures>({\n  ...defaultTableOptions\n}: CreateTableHookOptions<TFeatures>) {\n  function createAppColumnHelper<TData extends RowData>(): AppColumnHelper<\n    TFeatures,\n    TData\n  > {\n    return coreCreateColumnHelper<TFeatures, TData>()\n  }\n\n  function createAppTable<TData extends RowData>(\n    getTableOptions: () => Omit<TableOptions<TFeatures, TData>, 'features'>,\n  ): AppEmberTable<TFeatures, TData> {\n    // Keep options a thunk: the merge runs inside `useTable`'s options thunk,\n    // so tracked properties read in `getTableOptions` stay reactive. Per-table\n    // options take precedence over the shared defaults (except `features`,\n    // which only the hook provides).\n    return useTable<TFeatures, TData>(\n      () =>\n        ({\n          ...defaultTableOptions,\n          ...getTableOptions(),\n        }) as TableOptions<TFeatures, TData>,\n    )\n  }\n\n  return {\n    appFeatures: defaultTableOptions.features as TFeatures,\n    createAppColumnHelper,\n    createAppTable,\n  }\n}\n"],"names":["subscribeNoEffect","Signal","g","prototype","tracked","i","Set","constructor","value","options","_value","subscribe","listenerOrObserver","listener","next","unsubscribe","add","delete","get","set","update","prev","untrack","isEqual","compare","fn","original","ComputedSignal","compute","n","cached","signal","createAtom","initialValue","computed","emberReactivity","subscriptions","createOptionsStore","wrapExternalAtoms","schedule","queueMicrotask","batch","createReadonlyAtom","createWritableAtom","addSubscription","subscription","unmount","forEach","s","clear","useTable","getOptions","reactivity","userOptions","initialOptions","table","constructTable","features","coreReactivityFeature","mergeOptions","defaultOptions","newOptions","optionsStore","liveOptions","stored","atoms","Object","defineProperty","configurable","enumerable","stateKeys","keys","baseAtoms","key","baseAtom","externalAtom","stateSlice","state","undefined","debugName","stateProxy","Proxy","_target","has","includes","ownKeys","getOwnPropertyDescriptor","store","createTableHook","defaultTableOptions","createAppColumnHelper","coreCreateColumnHelper","createAppTable","getTableOptions","appFeatures"],"mappings":"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"}

package/dist/static-functions.js

@@ -0,0 +1,2 @@
+export * from '@tanstack/table-core/static-functions';
+//# sourceMappingURL=static-functions.js.map

package/dist/static-functions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"static-functions.js","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/package.json

@@ -0,0 +1,147 @@
+{
+  "name": "@tanstack/ember-table",
+  "version": "9.0.0-beta.0",
+  "description": "Headless UI for building powerful tables & datagrids for Ember.",
+  "author": "Tanner Linsley",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/TanStack/table.git",
+    "directory": "packages/ember-table"
+  },
+  "homepage": "https://tanstack.com/table",
+  "funding": {
+    "type": "github",
+    "url": "https://github.com/sponsors/tannerlinsley"
+  },
+  "keywords": [
+    "ember",
+    "ember-addon",
+    "table",
+    "ember-table",
+    "datagrid",
+    "tanstack-intent"
+  ],
+  "type": "module",
+  "imports": {
+    "#src/*": "./src/*"
+  },
+  "exports": {
+    ".": {
+      "types": "./declarations/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./static-functions": {
+      "types": "./declarations/static-functions.d.ts",
+      "default": "./dist/static-functions.js"
+    },
+    "./flex-render": {
+      "types": "./declarations/flex-render.d.ts",
+      "default": "./dist/flex-render.js"
+    },
+    "./experimental-worker-plugin": {
+      "types": "./declarations/experimental-worker-plugin.d.ts",
+      "default": "./dist/experimental-worker-plugin.js"
+    },
+    "./addon-main.js": "./addon-main.cjs",
+    "./package.json": "./package.json"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "files": [
+    "addon-main.cjs",
+    "declarations",
+    "dist",
+    "src",
+    "skills"
+  ],
+  "scripts": {
+    "build": "rollup --config",
+    "clean": "rimraf ./dist ./declarations ./dist-tests",
+    "format": "prettier . --cache --write",
+    "lint": "concurrently \"pnpm:lint:*(!fix)\" --names \"lint:\" --prefixColors auto",
+    "lint:fix": "concurrently \"pnpm:lint:*:fix\" --names \"fix:\" --prefixColors auto && pnpm run format",
+    "lint:format": "prettier . --cache --check",
+    "lint:hbs": "ember-template-lint . --no-error-on-unmatched-pattern",
+    "lint:hbs:fix": "ember-template-lint . --fix --no-error-on-unmatched-pattern",
+    "lint:js": "eslint . --cache",
+    "lint:js:fix": "eslint . --fix",
+    "lint:types": "ember-tsc --noEmit",
+    "prepack": "rollup --config",
+    "start": "vite dev",
+    "test:build": "publint --strict",
+    "test:eslint": "eslint . --cache",
+    "test:lib": "vite build --mode=development --out-dir dist-tests && testem --file testem.cjs ci --port 0",
+    "test:types": "ember-tsc --noEmit"
+  },
+  "dependencies": {
+    "@embroider/addon-shim": "^1.8.9",
+    "@tanstack/store": "^0.11.0",
+    "@tanstack/table-core": "workspace:*",
+    "decorator-transforms": "2.4.0"
+  },
+  "devDependencies": {
+    "@babel/core": "7.29.7",
+    "@babel/eslint-parser": "^7.25.1",
+    "@babel/plugin-transform-typescript": "7.29.7",
+    "@babel/runtime": "7.29.7",
+    "@ember/app-tsconfig": "2.0.0",
+    "@ember/library-tsconfig": "^1.0.0",
+    "@ember/test-helpers": "^5.2.1",
+    "@ember/test-waiters": "^4.1.1",
+    "@embroider/addon-dev": "^8.1.0",
+    "@embroider/compat": "^4.1.0",
+    "@embroider/core": "4.6.2",
+    "@embroider/macros": "1.20.5",
+    "@embroider/vite": "^1.1.5",
+    "@eslint/js": "^9.17.0",
+    "@glimmer/component": "2.1.1",
+    "@glint/ember-tsc": "1.8.11",
+    "@glint/template": "1.7.8",
+    "@glint/tsserver-plugin": "2.5.17",
+    "@playwright/test": "^1.61.1",
+    "@rollup/plugin-babel": "7.1.0",
+    "@types/qunit": "^2.19.12",
+    "babel-plugin-ember-template-compilation": "4.0.0",
+    "concurrently": "^9.0.1",
+    "ember-page-title": "^9.0.3",
+    "ember-qunit": "^9.0.2",
+    "ember-source": "7.0.0",
+    "ember-strict-application-resolver": "0.1.1",
+    "ember-template-lint": "^7.9.0",
+    "eslint": "^9.17.0",
+    "eslint-config-prettier": "^10.1.5",
+    "eslint-plugin-ember": "^12.3.3",
+    "eslint-plugin-import": "^2.31.0",
+    "eslint-plugin-n": "^17.15.1",
+    "globals": "^16.1.0",
+    "prettier": "^3.8.4",
+    "publint": "^0.3.21",
+    "qunit": "^2.24.1",
+    "qunit-dom": "^3.4.0",
+    "rollup": "^4.22.5",
+    "testem": "^3.15.1",
+    "typescript": "6.0.3",
+    "typescript-eslint": "^8.19.1",
+    "vite": "^8.1.0"
+  },
+  "ember": {
+    "edition": "octane"
+  },
+  "ember-addon": {
+    "version": 2,
+    "type": "addon",
+    "main": "addon-main.cjs"
+  },
+  "nx": {
+    "targets": {
+      "build": {
+        "outputs": [
+          "{projectRoot}/dist",
+          "{projectRoot}/declarations"
+        ]
+      }
+    }
+  }
+}

package/skills/create-table-hook/SKILL.md

@@ -0,0 +1,117 @@
+---
+name: create-table-hook
+description: >
+  Share TanStack Ember Table v9 features, row-model slots, defaults, and inferred column helpers with createTableHook, createAppTable, createAppColumnHelper, and appFeatures. Load for recurring Ember table conventions, per-table overrides, or confusion with component/context registries from other adapters.
+metadata:
+  type: framework
+  library: '@tanstack/ember-table'
+  framework: ember
+  library_version: '9.0.0-beta.38'
+requires:
+  - '@tanstack/table-core#core'
+  - getting-started
+  - table-state
+sources:
+  - 'TanStack/table:docs/framework/ember/guide/composable-tables.md'
+  - 'TanStack/table:examples/ember/basic-app-table'
+  - 'TanStack/table:packages/ember-table/src/create-table-hook.ts'
+---
+
+This skill builds on `@tanstack/table-core#core`, `getting-started`, and `table-state`. Use an app factory when several tables share real features or defaults; keep a one-off table on `useTable`.
+
+## Setup
+
+```gts
+import Component from '@glimmer/component'
+import { tracked } from '@glimmer/tracking'
+import {
+  createSortedRowModel,
+  createTableHook,
+  rowSortingFeature,
+  sortFns,
+  tableFeatures,
+} from '@tanstack/ember-table'
+
+const features = tableFeatures({
+  rowSortingFeature,
+  sortedRowModel: createSortedRowModel(),
+  sortFns,
+})
+
+export const { appFeatures, createAppColumnHelper, createAppTable } =
+  createTableHook({
+    features,
+    enableSortingRemoval: false,
+  })
+
+type Person = { id: string; name: string }
+const columnHelper = createAppColumnHelper<Person>()
+const columns = columnHelper.columns([
+  columnHelper.accessor('name', { header: 'Name' }),
+])
+
+export default class PeopleTable extends Component {
+  @tracked data: Person[] = []
+
+  table = createAppTable(() => ({
+    columns,
+    data: this.data,
+  }))
+}
+```
+
+Create the hook and column helpers at stable module scope. `createAppTable` preserves the `useTable` options thunk, so tracked reads such as `this.data` remain reactive. Do not pass `features` again at the table call site; the factory owns the feature set and binds it into column inference.
+
+## Composition Contract
+
+- Hook options supply stable shared `features` and default table options.
+- `createAppColumnHelper<TData>()` binds the feature type while inferring each row type.
+- `createAppTable(() => options)` merges shared defaults with table-specific options.
+- Table-specific options win over shared defaults, except that the factory remains the feature owner.
+- `appFeatures` exposes the exact registered feature set for helper types or reusable utilities.
+
+Shared options intentionally exclude `columns`, `data`, and `state`. Keep model inputs and controlled state at each table call site; share conventions, not one mutable state object across unrelated tables.
+
+Sharing `rowSortingFeature`, `sortedRowModel`, and sorting defaults gives every table sorting capability; it does not make their internal sorting state shared. The factory technically accepts a stable external atom in shared `atoms`, but that deliberately couples tables and their column IDs. Prefer independent state unless synchronized tables are the actual product behavior.
+
+## Render Normally
+
+Ember's factory does not register `AppTable`, `AppCell`, `AppHeader`, context hooks, or reusable component registries. Continue rendering with `FlexRenderCell`, `FlexRenderHeader`, and `FlexRenderFooter`. Continue wrapping receiver-dependent v9 methods in Ember template helpers as described by `getting-started`.
+
+## Common Mistakes
+
+### HIGH Copying another adapter's component registry
+
+Wrong: expect `table.AppTable`, `useTableContext`, or a `tableComponents` option from React, Solid, Svelte, or Lit examples.
+
+Correct: use the normal Ember FlexRender components and pass the table through ordinary Ember composition when another component truly needs it.
+
+The Ember hook shares features/defaults and type inference only.
+
+### HIGH Passing features per table
+
+Wrong:
+
+```gts
+createAppTable(() => ({ features: otherFeatures, columns, data: this.data }))
+```
+
+Correct: define a separate app hook when a table needs a genuinely different feature set. `createAppTable` omits `features` from its call-site type.
+
+### HIGH Recreating the hook or columns with tracked updates
+
+Wrong: call `createTableHook`, `createAppColumnHelper`, or `columns(...)` inside a component getter or the `createAppTable` thunk.
+
+Correct: create them once at module scope and let the table thunk read only changing inputs.
+
+### MEDIUM Sharing controlled state as a default
+
+The hook options omit `state`. Put `state` and matching `on[State]Change` callbacks in each `createAppTable` thunk so every table has one clear owner per slice. Use a shared external atom only when tables intentionally coordinate the same compatible slice.
+
+### MEDIUM Repeating manual feature generics
+
+Use `createAppColumnHelper<Person>()`; do not thread `typeof features` through every column helper after the factory has already captured it.
+
+## API Discovery
+
+Inspect `node_modules/@tanstack/ember-table/src/create-table-hook.ts` for the installed factory return shape, omitted options, and merge precedence. Inspect `use-table.ts` for thunk reactivity and `node_modules/@tanstack/table-core/src/features/<feature>/` for the shared feature APIs. Do not infer Ember component/context behavior from another adapter's createTableHook.