@tulip-systems/core 0.8.3 → 0.10.0

package/dist/src/modules/commands/hooks/use-command.client.mjs

@@ -0,0 +1,45 @@
+"use client";
+
+import { jsx } from "react/jsx-runtime";
+import { createContext, useContext, useEffect, useRef, useState } from "react";
+
+//#region src/modules/commands/hooks/use-command.client.tsx
+const CommandContext = createContext(null);
+function useCommand() {
+	const context = useContext(CommandContext);
+	if (!context) throw new Error("useCommand must be used within CommandContextProvider");
+	return context;
+}
+function CommandContextProvider({ children, ui, disabled = false, onSuccess, onError, onSettled }) {
+	const [status, setStatus] = useState("idle");
+	const previousStatusRef = useRef("idle");
+	useEffect(() => {
+		if (status === previousStatusRef.current) return;
+		if (status === "success") {
+			onSuccess?.();
+			onSettled?.();
+		}
+		if (status === "error") {
+			onError?.();
+			onSettled?.();
+		}
+		previousStatusRef.current = status;
+	}, [
+		status,
+		onSuccess,
+		onError,
+		onSettled
+	]);
+	return /* @__PURE__ */ jsx(CommandContext.Provider, {
+		value: {
+			ui,
+			status,
+			disabled,
+			setStatus
+		},
+		children
+	});
+}
+
+//#endregion
+export { CommandContextProvider, useCommand };

package/dist/src/modules/commands/lib/builder.d.mts

@@ -0,0 +1,135 @@
+import { Permission } from "../../auth/lib/permissions.mjs";
+
+//#region src/modules/commands/lib/builder.d.ts
+/**
+ * The different UI contexts in which a command can be rendered.
+ */
+type CommandUI = "dropdown" | "context" | "table" | "inline" | "custom";
+/**
+ * The status of a command, which can be used to style the command's UI appropriately.
+ */
+type CommandStatus = "idle" | "pending" | "success" | "error";
+/**
+ * A string tag that can be added to a command for organizational and filtering purposes.
+ */
+type CommandTag = string;
+/**
+ * Represents a command definition with its associated types and properties.
+ */
+type AnyCommandDef = CommandDef<any, any, any, any>;
+/**
+ * Condition function that determines whether a command is visible or disabled based on the provided data and meta.
+ */
+type CommandCondition<TData, TMeta> = (params: {
+  data: TData;
+  meta: TMeta;
+}) => boolean | boolean[];
+/**
+ * Render function that defines how a command should be rendered based on the provided data, meta, and UI context.
+ */
+type CommandRender<TData, TMeta> = (params: {
+  data: TData;
+  meta: TMeta;
+  ui: CommandUI;
+}) => React.ReactNode;
+/**
+ * Final command definition (without name).
+ * Name is derived from the object key in `defineCommands`.
+ *
+ * @typeParam TData  - The type `visibleWhen`, `disabledWhen`, and `render` receive.
+ *                    When `.transform()` is used this is the post-transform type.
+ * @typeParam TMeta  - Shared contextual metadata passed alongside data.
+ * @typeParam TTags  - Literal tuple of tag strings preserved from the builder's
+ *                    `.tags()` call. Enables compile-time tag filtering in the
+ *                    registry. Defaults to `string[]` when not provided.
+ * @typeParam TInput - The type that menus must pass as `data`. Equals `TData`
+ *                    when no `.transform()` is used. When `.transform(fn)` is
+ *                    called, `TInput` captures the pre-transform type so menus
+ *                    remain correctly typed while `render` sees the transformed type.
+ *                    Structurally expressed as the parameter of `transform`.
+ */
+type CommandDef<TData = unknown, TMeta = object, TTags extends readonly string[] = string[], TInput = TData> = {
+  id?: string;
+  tags: TTags;
+  transform?: (data: TInput) => TData;
+  permission?: Permission;
+  visibleWhen?: CommandCondition<TData, TMeta>;
+  disabledWhen?: CommandCondition<TData, TMeta>;
+  render: CommandRender<TData, TMeta>;
+};
+/**
+ * Command typed by accepted input data.
+ *
+ * Useful for APIs that only care about what can be passed in (e.g. table
+ * providers that always pass selected rows), not the command's normalized
+ * render-time shape.
+ */
+type CommandFor<TInput, TMeta = object> = CommandDef<any, TMeta, any, TInput>;
+/**
+ * Extracts the **input** data type of a command — what menus must pass as `data`.
+ *
+ * - When `.transform()` is used, this is the pre-transform type (e.g. `Template | Template[]`).
+ * - Otherwise it equals the render-time type.
+ *
+ * The type is read from the `transform` field's parameter when present, and
+ * falls back to the `render` parameter when there is no transformer.
+ */
+type ExtractCommandData<TCommand extends AnyCommandDef> = [NonNullable<TCommand["transform"]>] extends [never] ? TCommand extends {
+  render: (params: {
+    data: infer TData;
+    meta: any;
+    ui: any;
+  }) => any;
+} ? TData : never : NonNullable<TCommand["transform"]> extends ((data: infer TInput) => any) ? TInput : never;
+/**
+ * Builder state after `.$type<TData>()` has been called (or at initial state
+ * with `TData = unknown`).
+ *
+ * @typeParam TData  - Current render-time data type (post-transform if used).
+ * @typeParam TTags  - Literal tag tuple, carried through every method so that
+ *                    the final `CommandDef` retains the literal type.
+ * @typeParam TInput - Input data type for menus. Starts equal to `TData`.
+ *                    Freezes to the value of `TData` at the moment `.transform()`
+ *                    is called, while `TData` changes to the transformer's output.
+ */
+type ReadyCommandBuilder<TData, TMeta, TTags extends readonly string[] = string[], TInput = TData> = {
+  /** Override the data (and optionally meta) type. Resets `TInput` to the new `TData`. */$type<TNewData, TNewMeta = TMeta>(): ReadyCommandBuilder<TNewData, TNewMeta, TTags, TNewData>;
+  /**
+   * Set the command's tags as a literal tuple. The `const` modifier infers
+   * string arguments as literals, enabling compile-time tag narrowing in the registry.
+   */
+  tags<const TNewTags extends string[]>(...tags: TNewTags): ReadyCommandBuilder<TData, TMeta, TNewTags, TInput>;
+  permission(permission: Permission): ReadyCommandBuilder<TData, TMeta, TTags, TInput>;
+  /**
+   * Declares a lightweight transformer that runs once per render — before `visibleWhen`,
+   * `disabledWhen`, and `render` — collapsing the input type into a single usable shape.
+   *
+   * Freezes `TInput` to the current `TData` (the pre-transform type) and advances
+   * `TData` to `TNewData` (the transformer's return type). This ensures:
+   * - Menus are typed against the union input (e.g. `Template | Template[]`)
+   * - `visibleWhen` and `render` work with the clean transformed type (e.g. `Template[]`)
+   *
+   * @example
+   * commandBuilder
+   *   .$type<Template | Template[]>()
+   *   .transform((data) => (Array.isArray(data) ? data : [data]))
+   *   .visibleWhen(({ data }) => data.length > 0)  // data: Template[]
+   *   .render(({ data }) => <ArchiveCommand ids={data.map(i => i.id)} />)
+   */
+  transform<TNewData>(fn: (data: TData) => TNewData): ReadyCommandBuilder<TNewData, TMeta, TTags, TData>;
+  visibleWhen(condition: CommandCondition<TData, TMeta>): ReadyCommandBuilder<TData, TMeta, TTags, TInput>;
+  disabledWhen(condition: CommandCondition<TData, TMeta>): ReadyCommandBuilder<TData, TMeta, TTags, TInput>; /** Terminal — produces the final `CommandDef`. */
+  render(render: CommandRender<TData, TMeta>): CommandDef<TData, TMeta, TTags, TInput>;
+};
+/**
+ * The initial builder returned by `commandBuilder` / `createCommandBuilder()`.
+ * Before `.$type<>()` is called, `TData` is `unknown`.
+ */
+type InitialCommandBuilder<TMeta> = ReadyCommandBuilder<unknown, TMeta, string[], unknown> & {
+  $type<TNewData, TNewMeta = TMeta>(): ReadyCommandBuilder<TNewData, TNewMeta, string[], TNewData>;
+  tags<const TNewTags extends string[]>(...tags: TNewTags): ReadyCommandBuilder<unknown, TMeta, TNewTags, unknown>;
+};
+declare function createCommandBuilder<TMeta = object>(): InitialCommandBuilder<TMeta>;
+declare const commandBuilder: InitialCommandBuilder<object>;
+//#endregion
+export { AnyCommandDef, CommandCondition, CommandDef, CommandFor, CommandRender, CommandStatus, CommandTag, CommandUI, ExtractCommandData, commandBuilder, createCommandBuilder };

package/dist/src/modules/commands/lib/builder.mjs

@@ -0,0 +1,82 @@
+//#region src/modules/commands/lib/builder.ts
+function createInitialBuilder(state) {
+	return {
+		...createReadyBuilder({
+			tags: state.tags ?? [],
+			permission: state.permission
+		}),
+		tags(...tags) {
+			return createReadyBuilder({
+				tags,
+				permission: state.permission
+			});
+		},
+		$type() {
+			return createReadyBuilder({
+				tags: state.tags ?? [],
+				permission: state.permission
+			});
+		}
+	};
+}
+function createReadyBuilder(state) {
+	return {
+		$type() {
+			return createReadyBuilder({
+				tags: state.tags,
+				permission: state.permission
+			});
+		},
+		tags(...tags) {
+			return createReadyBuilder({
+				tags,
+				permission: state.permission,
+				transform: state.transform,
+				visibleWhen: state.visibleWhen,
+				disabledWhen: state.disabledWhen
+			});
+		},
+		permission(permission) {
+			return createReadyBuilder({
+				...state,
+				permission
+			});
+		},
+		transform(fn) {
+			return createReadyBuilder({
+				tags: state.tags,
+				permission: state.permission,
+				transform: fn
+			});
+		},
+		visibleWhen(condition) {
+			return createReadyBuilder({
+				...state,
+				visibleWhen: condition
+			});
+		},
+		disabledWhen(condition) {
+			return createReadyBuilder({
+				...state,
+				disabledWhen: condition
+			});
+		},
+		render(render) {
+			return {
+				tags: state.tags,
+				transform: state.transform,
+				permission: state.permission,
+				visibleWhen: state.visibleWhen,
+				disabledWhen: state.disabledWhen,
+				render
+			};
+		}
+	};
+}
+function createCommandBuilder() {
+	return createInitialBuilder({});
+}
+const commandBuilder = createCommandBuilder();
+
+//#endregion
+export { commandBuilder, createCommandBuilder };

package/dist/src/modules/commands/lib/registery.d.mts

@@ -0,0 +1,68 @@
+import { AnyCommandDef } from "./builder.mjs";
+
+//#region src/modules/commands/lib/registery.d.ts
+/**
+ * Command map type defining the shape of command definitions.
+ */
+type CommandMap = Record<string, AnyCommandDef>;
+/** Union of all values in a command map. */
+type ValueOf<TCommands extends CommandMap> = TCommands[keyof TCommands];
+/** Keep commands that have **every** of `TFilterTags`. */
+type FilterAllTags<TCommand extends AnyCommandDef, TFilterTags extends readonly string[]> = TCommand extends {
+  tags: infer CmdTags extends readonly string[];
+} ? TFilterTags[number] extends CmdTags[number] ? TCommand : never : TCommand;
+/** Keep commands that have **some** of `TFilterTags`. */
+type FilterAnyTags<TCommand extends AnyCommandDef, TFilterTags extends readonly string[]> = TCommand extends {
+  tags: infer CmdTags extends readonly string[];
+} ? string[] extends CmdTags ? TCommand : Extract<CmdTags[number], TFilterTags[number]> extends never ? never : TCommand : TCommand;
+/** Keep commands whose tag set equals `TFilterTags` (order-insensitive). */
+type FilterExactTags<TCommand extends AnyCommandDef, TFilterTags extends readonly string[]> = TCommand extends {
+  tags: infer CmdTags extends readonly string[];
+} ? string[] extends CmdTags ? TCommand : [CmdTags[number]] extends [TFilterTags[number]] ? [TFilterTags[number]] extends [CmdTags[number]] ? TCommand : never : never : TCommand;
+/** Keep commands that have **without** of `TFilterTags`. */
+type FilterWithoutTags<TCommand extends AnyCommandDef, TFilterTags extends readonly string[]> = TCommand extends {
+  tags: infer CmdTags extends readonly string[];
+} ? string[] extends CmdTags ? TCommand : Extract<CmdTags[number], TFilterTags[number]> extends never ? TCommand : never : TCommand;
+type CommandKey<TCommands extends CommandMap> = Extract<keyof TCommands, string>;
+type CommandFlags<TCommands extends CommandMap> = Partial<Record<CommandKey<TCommands>, boolean>>;
+type CommandInput<TCommands extends CommandMap> = readonly CommandKey<TCommands>[] | CommandFlags<TCommands>;
+type TruthyKeys<T> = { [K in keyof T]-?: T[K] extends true ? K : never }[keyof T];
+type PickedCommands<TCommands extends CommandMap, TInput extends CommandInput<TCommands>> = TInput extends readonly CommandKey<TCommands>[] ? Pick<TCommands, TInput[number]> : TInput extends CommandFlags<TCommands> ? Pick<TCommands, Extract<TruthyKeys<TInput>, keyof TCommands>> : never;
+type OmittedCommands<TCommands extends CommandMap, TInput extends CommandInput<TCommands>> = TInput extends readonly CommandKey<TCommands>[] ? Omit<TCommands, TInput[number]> : TInput extends CommandFlags<TCommands> ? Omit<TCommands, Extract<TruthyKeys<TInput>, keyof TCommands>> : never;
+type ExtendedCommands<TBase extends CommandMap, TExtension extends CommandMap> = Omit<TBase, keyof TExtension> & TExtension;
+type CommandTagFilterRegistry<TCommand extends AnyCommandDef> = {
+  every<const TTags extends string[]>(...tags: TTags): CommandTagFilterRegistry<FilterAllTags<TCommand, TTags>>;
+  some<const TTags extends string[]>(...tags: TTags): CommandTagFilterRegistry<FilterAnyTags<TCommand, TTags>>;
+  exact<const TTags extends string[]>(...tags: TTags): CommandTagFilterRegistry<FilterExactTags<TCommand, TTags>>;
+  without<const TTags extends string[]>(...tags: TTags): CommandTagFilterRegistry<FilterWithoutTags<TCommand, TTags>>;
+  toArray(): TCommand[];
+};
+type CommandKeyFilterRegistry<TCommands extends CommandMap> = {
+  pick<const TInput extends CommandInput<TCommands>>(input: TInput): CommandKeyFilterRegistry<PickedCommands<TCommands, TInput>>;
+  omit<const TInput extends CommandInput<TCommands>>(input: TInput): CommandKeyFilterRegistry<OmittedCommands<TCommands, TInput>>;
+  toArray(): ValueOf<TCommands>[];
+};
+type CommandRegistry<TCommands extends CommandMap> = {
+  commands: TCommands;
+  keys: CommandKeyFilterRegistry<TCommands>;
+  tags: CommandTagFilterRegistry<ValueOf<TCommands>>;
+  extend<const TExtension extends CommandMap>(extension: TExtension): CommandRegistry<ExtendedCommands<TCommands, TExtension>>; /** @deprecated Use `commands.keys.pick(...)` instead. */
+  pick<const TInput extends CommandInput<TCommands>>(input: TInput): CommandRegistry<PickedCommands<TCommands, TInput>>; /** @deprecated Use `commands.keys.omit(...)` instead. */
+  omit<const TInput extends CommandInput<TCommands>>(input: TInput): CommandRegistry<OmittedCommands<TCommands, TInput>>;
+  toArray(): ValueOf<TCommands>[];
+};
+/**
+ * Define commands from a map of name → `CommandDef`.
+ *
+ * Returns a `CommandRegistry` with key-based and tag-based filtering, plus
+ * `extend` for composition. Filter chains are immutable — each call produces
+ * a new registry.
+ *
+ * @example
+ * const registry = defineCommands({ edit, delete, archive });
+ * registry.tags.every("danger", "table").toArray();
+ * registry.keys.omit({ delete: true }).toArray();
+ */
+declare function defineCommands<TCommands extends CommandMap>(commands: TCommands): CommandRegistry<TCommands>;
+//#endregion
+export { CommandMap, defineCommands };

package/dist/src/modules/commands/lib/registery.mjs

@@ -0,0 +1,103 @@
+//#region src/modules/commands/lib/registery.ts
+function resolveKeys(input) {
+	if (Array.isArray(input)) return [...input];
+	return Object.entries(input).filter(([, enabled]) => enabled === true).map(([key]) => key);
+}
+function dedupe(tags) {
+	return [...new Set(tags)];
+}
+function hasEveryTag(command, tags) {
+	return tags.every((tag) => command.tags.includes(tag));
+}
+function hasSomeTag(command, tags) {
+	return tags.some((tag) => command.tags.includes(tag));
+}
+function hasExactTags(command, tags) {
+	const ctags = dedupe(command.tags);
+	const ftags = dedupe(tags);
+	return ctags.length === ftags.length && ftags.every((t) => ctags.includes(t));
+}
+function injectIds(commands) {
+	return Object.fromEntries(Object.entries(commands).map(([id, c]) => [id, {
+		...c,
+		id
+	}]));
+}
+function pickCommands(commands, input) {
+	const keys = resolveKeys(input);
+	return Object.fromEntries(keys.filter((k) => k in commands).map((k) => [k, commands[k]]));
+}
+function omitCommands(commands, input) {
+	const keys = new Set(resolveKeys(input));
+	return Object.fromEntries(Object.entries(commands).filter(([k]) => !keys.has(k)));
+}
+function createTagFilterRegistry(commands) {
+	function apply(predicate) {
+		return (...tags) => {
+			return createTagFilterRegistry(commands.filter((c) => predicate(c, tags)));
+		};
+	}
+	return {
+		every: apply(hasEveryTag),
+		some: apply(hasSomeTag),
+		exact: apply(hasExactTags),
+		without: apply((c, ts) => !hasSomeTag(c, ts)),
+		toArray() {
+			return commands;
+		}
+	};
+}
+function createKeyFilterRegistry(commands) {
+	return {
+		pick(input) {
+			return createKeyFilterRegistry(pickCommands(commands, input));
+		},
+		omit(input) {
+			return createKeyFilterRegistry(omitCommands(commands, input));
+		},
+		toArray() {
+			return Object.values(commands);
+		}
+	};
+}
+function createRegistry(commands) {
+	const withIds = injectIds(commands);
+	return {
+		commands: withIds,
+		keys: createKeyFilterRegistry(withIds),
+		tags: createTagFilterRegistry(Object.values(withIds)),
+		extend(extension) {
+			return createRegistry({
+				...withIds,
+				...extension
+			});
+		},
+		pick(input) {
+			return createRegistry(pickCommands(withIds, input));
+		},
+		omit(input) {
+			return createRegistry(omitCommands(withIds, input));
+		},
+		toArray() {
+			return Object.values(withIds);
+		}
+	};
+}
+/**
+* Define commands from a map of name → `CommandDef`.
+*
+* Returns a `CommandRegistry` with key-based and tag-based filtering, plus
+* `extend` for composition. Filter chains are immutable — each call produces
+* a new registry.
+*
+* @example
+* const registry = defineCommands({ edit, delete, archive });
+* registry.tags.every("danger", "table").toArray();
+* registry.keys.omit({ delete: true }).toArray();
+*/
+function defineCommands(commands) {
+	return createRegistry(commands);
+}
+
+//#endregion
+export { defineCommands };

package/dist/src/modules/commands/lib/utils.d.mts

@@ -0,0 +1,11 @@
+//#region src/modules/commands/lib/utils.d.ts
+/**
+ * Normalizes command data into an array.
+ *
+ * Use this as a command transform when the same command should support both
+ * single-item and bulk contexts. After `.transform(ensureArray)`, command
+ * callbacks can safely use array helpers like `.map` and `.every`.
+ */
+declare function ensureArray<T>(data: T | T[]): T[];
+//#endregion
+export { ensureArray };

package/dist/src/modules/commands/lib/utils.mjs

@@ -0,0 +1,14 @@
+//#region src/modules/commands/lib/utils.ts
+/**
+* Normalizes command data into an array.
+*
+* Use this as a command transform when the same command should support both
+* single-item and bulk contexts. After `.transform(ensureArray)`, command
+* callbacks can safely use array helpers like `.map` and `.every`.
+*/
+function ensureArray(data) {
+	return Array.isArray(data) ? data : [data];
+}
+
+//#endregion
+export { ensureArray };

package/dist/src/modules/config/lib/config.d.mts

@@ -0,0 +1,16 @@
+//#region src/modules/config/lib/config.d.ts
+type TulipConfig<TValues = object> = {
+  general: {
+    name: string;
+    shortName: string;
+  };
+  email: {
+    defaultFrom: string;
+  };
+} & TValues;
+/**
+ * Build the Tulip config
+ */
+declare const defineTulipConfig: <TValues>(config: TulipConfig<TValues>) => TulipConfig<TValues>;
+//#endregion
+export { TulipConfig, defineTulipConfig };

package/dist/src/modules/config/lib/config.mjs

@@ -0,0 +1,8 @@
+//#region src/modules/config/lib/config.ts
+/**
+* Build the Tulip config
+*/
+const defineTulipConfig = (config) => config;
+
+//#endregion
+export { defineTulipConfig };

package/dist/src/modules/config/lib/context.d.mts

@@ -0,0 +1,17 @@
+import { TDatabaseSchema } from "../../database/lib/types.mjs";
+import { Database } from "../../database/lib/service.server.mjs";
+import { Email } from "../../emails/lib/service.server.mjs";
+import { Auth } from "../../auth/handler/service.server.mjs";
+import { Storage } from "../../storage/lib/service.server.mjs";
+
+//#region src/modules/config/lib/context.d.ts
+type TulipContext<TSchema extends TDatabaseSchema> = {
+  db: Database<TSchema>;
+  schema: TSchema;
+  auth: Auth;
+  email: Email;
+  storage: Storage<TSchema>;
+};
+declare function createContext<TSchema extends TDatabaseSchema>(props: TulipContext<TSchema>): TulipContext<TSchema>;
+//#endregion
+export { TulipContext, createContext };

package/dist/src/modules/config/lib/context.mjs

@@ -0,0 +1,7 @@
+//#region src/modules/config/lib/context.ts
+function createContext(props) {
+	return props;
+}
+
+//#endregion
+export { createContext };

package/dist/src/modules/config/paths/helpers.d.mts

@@ -0,0 +1,9 @@
+import { Paths } from "./types.mjs";
+
+//#region src/modules/config/paths/helpers.d.ts
+/**
+ * Create the paths object
+ */
+declare const createPaths: (paths: Paths) => Paths;
+//#endregion
+export { createPaths };

package/dist/src/modules/config/paths/helpers.mjs

@@ -0,0 +1,8 @@
+//#region src/modules/config/paths/helpers.ts
+/**
+* Create the paths object
+*/
+const createPaths = (paths) => paths;
+
+//#endregion
+export { createPaths };

package/dist/src/modules/config/paths/types.d.mts

@@ -0,0 +1,31 @@
+import { Permission } from "../../auth/lib/permissions.mjs";
+import { LucideIcon } from "lucide-react";
+import { Route } from "next";
+
+//#region src/modules/config/paths/types.d.ts
+/**
+ * Path types
+ */
+type PathGroup = {
+  name?: string;
+  items: Path[];
+};
+type Path = {
+  name: string;
+  href: Route;
+  icon?: LucideIcon;
+  segment?: string;
+  permission?: Permission;
+  isActive?: boolean;
+  items?: PathSubItem[];
+};
+type PathSubItem = {
+  name: string;
+  href: Route;
+  segment?: string;
+  permission?: Permission;
+  isActive?: boolean;
+};
+type Paths = PathGroup[];
+//#endregion
+export { Path, PathGroup, PathSubItem, Paths };

package/dist/src/modules/data-tables/components/cell/common.client.d.mts

@@ -0,0 +1,26 @@
+import { TableCell } from "../table.mjs";
+import * as react_jsx_runtime0 from "react/jsx-runtime";
+import { ComponentProps } from "react";
+
+//#region src/modules/data-tables/components/cell/common.client.d.ts
+declare function TableTextCell({
+  children,
+  className,
+  ...props
+}: ComponentProps<typeof TableCell>): react_jsx_runtime0.JSX.Element;
+declare function TableNumberCell({
+  children,
+  className,
+  ...props
+}: ComponentProps<typeof TableCell>): react_jsx_runtime0.JSX.Element;
+declare function TableDateCell({
+  children,
+  className,
+  ...props
+}: ComponentProps<typeof TableCell>): react_jsx_runtime0.JSX.Element;
+declare function TableStatusCell({
+  children,
+  ...props
+}: ComponentProps<typeof TableCell>): react_jsx_runtime0.JSX.Element;
+//#endregion
+export { TableDateCell, TableNumberCell, TableStatusCell, TableTextCell };

package/dist/src/modules/data-tables/components/cell/common.client.mjs

@@ -0,0 +1,35 @@
+import { cn } from "../../../../lib/utils/cn.mjs";
+import { TableCell } from "../table.mjs";
+import { jsx } from "react/jsx-runtime";
+
+//#region src/modules/data-tables/components/cell/common.client.tsx
+function TableTextCell({ children, className, ...props }) {
+	return /* @__PURE__ */ jsx(TableCell, {
+		...props,
+		className: cn("text-left", className),
+		children
+	});
+}
+function TableNumberCell({ children, className, ...props }) {
+	return /* @__PURE__ */ jsx(TableCell, {
+		...props,
+		className: cn("text-left", className),
+		children
+	});
+}
+function TableDateCell({ children, className, ...props }) {
+	return /* @__PURE__ */ jsx(TableCell, {
+		...props,
+		className: cn("text-left", className),
+		children
+	});
+}
+function TableStatusCell({ children, ...props }) {
+	return /* @__PURE__ */ jsx(TableCell, {
+		...props,
+		children
+	});
+}
+
+//#endregion
+export { TableDateCell, TableNumberCell, TableStatusCell, TableTextCell };

package/dist/src/modules/data-tables/components/cell/index.client.d.mts

@@ -0,0 +1,10 @@
+import { TableColumnDef } from "../../lib/types.mjs";
+import "../../../../../data-tables.mjs";
+
+//#region src/modules/data-tables/components/cell/index.client.d.ts
+/**
+ * Create a new column with a row index
+ */
+declare const createTableIndexCell: <TData>(newColumn?: Partial<TableColumnDef<TData>>) => TableColumnDef<TData>;
+//#endregion
+export { createTableIndexCell };

package/dist/src/modules/data-tables/components/cell/index.client.mjs

@@ -0,0 +1,24 @@
+import { TableColumnHeader } from "../column-header.mjs";
+import { TableNumberCell } from "./common.client.mjs";
+import { createTableCell } from "../../lib/helpers/create-column.mjs";
+import { jsx } from "react/jsx-runtime";
+
+//#region src/modules/data-tables/components/cell/index.client.tsx
+/**
+* Create a new column with a row index
+*/
+const createTableIndexCell = createTableCell({
+	accessorKey: "index",
+	permissions: { developer: ["debug"] },
+	header: ({ column }) => /* @__PURE__ */ jsx(TableColumnHeader, {
+		column,
+		title: "Index"
+	}),
+	cell: ({ row }) => /* @__PURE__ */ jsx(TableNumberCell, {
+		className: "w-10",
+		children: row.getValue("index")
+	})
+});
+
+//#endregion
+export { createTableIndexCell };