@tulip-systems/core 0.10.0 → 0.10.2

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

@@ -1,45 +0,0 @@
-"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

@@ -1,135 +0,0 @@
-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

@@ -1,82 +0,0 @@
-//#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

@@ -1,68 +0,0 @@
-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

@@ -1,103 +0,0 @@
-//#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

@@ -1,11 +0,0 @@
-//#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

@@ -1,14 +0,0 @@
-//#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

@@ -1,16 +0,0 @@
-//#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

@@ -1,8 +0,0 @@
-//#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

@@ -1,17 +0,0 @@
-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

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

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

@@ -1,9 +0,0 @@
-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

@@ -1,8 +0,0 @@
-//#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

@@ -1,31 +0,0 @@
-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

@@ -1,26 +0,0 @@
-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

@@ -1,35 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1,24 +0,0 @@
-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 };