@zoobzio/browser 0.0.0-stage → 0.0.0

package/.dist/index.d.mts

@@ -0,0 +1,331 @@
+import { Change as Change$1, Changers as Changers$1, Changes as Changes$1, Listener as Listener$1, Middleware as Middleware$1, Options as Options$1 } from "@zoobzio/kit";
+/**
+ * Column data type — drives cell rendering and sort behavior.
+ */
+export type ColumnType = "text" | "number" | "date" | "datetime" | "boolean" | "enum" | "currency" | "filesize" | "url" | "image" | "action";
+/**
+ * A file column — what the browser renders per file row.
+ */
+export interface BrowserColumn<T> {
+  key: keyof T;
+  label: string;
+  type?: ColumnType;
+  align?: "left" | "center" | "right";
+  sortable?: boolean;
+  sortKey?: string;
+  enumValues?: string[];
+}
+export type SortDirection = "asc" | "desc";
+/**
+ * The serializable half of a file/folder/bulk action: how it renders. The
+ * behavior half is a handler registered under the same key in `Actions`.
+ */
+export interface ActionDescriptor {
+  label: string;
+}
+/**
+ * File action — the live shape the service exposes: descriptor joined with
+ * its handler, under the config key. `runAction(key, row)` dispatches by
+ * key.
+ */
+export interface FileAction<T> {
+  key: string;
+  label: string;
+  action: (row: T) => void;
+}
+/**
+ * Bulk action over the selected files — the live shape the service exposes:
+ * descriptor joined with its handler, under the config key.
+ * `runBulkAction(key)` dispatches by key over the service's selection.
+ */
+export interface BulkAction {
+  key: string;
+  label: string;
+  action: (selected: Set<string>) => void;
+}
+/**
+ * A folder row — fixed on purpose: consumers map their folder data into it,
+ * and folder rendering customizes through the view. Files stay generic;
+ * folders do not.
+ */
+export type BrowserFolder = {
+  key: string;
+  label: string;
+  count?: number;
+};
+/**
+ * One step of the navigation trail. State keeps the full crumb (key and
+ * label) so breadcrumb labels survive navigation without a refetch; fetch
+ * params and events carry keys only.
+ */
+export type BrowserCrumb = {
+  key: string;
+  label: string;
+};
+/**
+ * Parameters passed to the fetch action. The browser owns navigation and
+ * file sort: `path` is the folder-key trail from the root (`[]` = root).
+ * Sorting applies to files only — folders always render alphabetically,
+ * enforced by the service regardless of fetch order.
+ */
+export interface BrowserFetchParams {
+  path: string[];
+  sortField: string | null;
+  sortDirection: SortDirection;
+}
+export interface BrowserFetchResult<T> {
+  folders: BrowserFolder[];
+  files: T[];
+}
+/**
+ * Folder action — rendered per-folder in an actions menu. The live shape
+ * the service exposes: descriptor joined with its handler, under the config
+ * key. `runFolderAction(key, folder)` dispatches by key.
+ */
+export type FolderAction = {
+  key: string;
+  label: string;
+  action: (folder: BrowserFolder) => void;
+};
+/**
+ * Config the consumer provides — pure serializable data. Actions are
+ * descriptor records: the key is the action's identity, shared with the
+ * handler record in `Actions`. `actions`/`bulkActions` cover files
+ * (selection is files-only); `folderActions` covers folder rows.
+ */
+export type Config<T> = {
+  columns: BrowserColumn<T>[];
+  fileKey: keyof T;
+  /**
+   * The label of the root crumb. Defaults to `Home`.
+   */
+  rootLabel?: string;
+  actions?: Record<string, ActionDescriptor>;
+  folderActions?: Record<string, ActionDescriptor>;
+  bulkActions?: Record<string, ActionDescriptor>;
+  /**
+   * The BCP 47 locale cells format in. Defaults to `en-US`.
+   */
+  locale?: string;
+  /**
+   * The ISO 4217 code currency cells format in. Defaults to `USD`.
+   */
+  currency?: string;
+};
+/**
+ * The state container the service reads and writes: the listing, the load
+ * flags, the trail, the file sort, and the selection. The container can be
+ * a plain object or a reactive proxy. The service replaces each member as a
+ * whole, so a proxy tracks every change.
+ */
+export type State<T> = {
+  folders: BrowserFolder[];
+  files: T[];
+  loading: boolean;
+  initialized: boolean;
+  path: BrowserCrumb[];
+  sortField: string | null;
+  sortDirection: SortDirection;
+  selected: Set<string>;
+};
+export type StateKey = keyof State<unknown>;
+/**
+ * The kit's state mechanisms bound to this service's container: per-field
+ * middleware, the read/write options, and the change objects.
+ */
+export type Middleware<T> = Middleware$1<State<T>>;
+export type Options<T> = Options$1<State<T>>;
+export type Changes<T> = Changes$1<State<T>>;
+export type Change<T, K extends StateKey = StateKey> = Change$1<State<T>, K>;
+export type Changers<T> = Changers$1<State<T>>;
+/**
+ * The consumer-supplied behavior: the fetch mechanism plus handlers keyed
+ * like the config's descriptor records.
+ */
+export type Actions<T> = {
+  fetch: (params: BrowserFetchParams, service: Service<T>) => Promise<BrowserFetchResult<T>>;
+  actions?: Record<string, (row: T) => void>;
+  folderActions?: Record<string, (folder: BrowserFolder) => void>;
+  bulkActions?: Record<string, (selected: Set<string>) => void>;
+};
+/**
+ * The events of a browser service, keyed by name. Each value is the
+ * argument list of a listener. The service emits after the write lands, so
+ * a listener reads the new state.
+ *
+ * - `change`: any field of the container was written.
+ * - `updated`: a fetch settled, success or failure. `path` is the key trail,
+ *   `folders`/`files` the section lengths.
+ * - `navigated`: the trail changed through `open` or `navigate`.
+ */
+export type Events<T> = {
+  change: [change: Change<T>];
+  updated: [event: {
+    id: string;
+    path: string[];
+    folders: number;
+    files: number;
+  }];
+  navigated: [event: {
+    id: string;
+    path: string[];
+  }];
+};
+export type Event<T> = keyof Events<T>;
+export type Listener<T, E extends Event<T>> = Listener$1<Events<T>, E>;
+/**
+ * The imperative contract: unwrapped state + derived + the full method
+ * surface. `BrowserService<T>` declares `implements` against this, and the
+ * fetch action receives it.
+ */
+export type Service<T> = {
+  readonly id: string;
+  readonly config: Config<T>;
+  readonly columns: BrowserColumn<T>[];
+  readonly fileKey: keyof T;
+  readonly actions: FileAction<T>[];
+  readonly folderActions: FolderAction[];
+  readonly bulkActions: BulkAction[];
+  readonly rootLabel: string;
+  readonly locale: string;
+  readonly currency: string;
+  readonly folders: BrowserFolder[];
+  readonly files: T[];
+  readonly loading: boolean;
+  readonly initialized: boolean;
+  readonly path: BrowserCrumb[];
+  readonly sortField: string | null;
+  readonly sortDirection: SortDirection;
+  readonly selected: Set<string>;
+  readonly pathKeys: string[];
+  readonly depth: number;
+  /**
+   * The breadcrumb trail: the root crumb, then one crumb per trail step.
+   * Each crumb's key is its joined path prefix, unique even when one folder
+   * key recurs at several depths; its index is what `navigate` takes.
+   */
+  readonly trail: BrowserCrumb[];
+  readonly isAllSelected: boolean;
+  readonly isIndeterminate: boolean;
+  readonly selectAllState: boolean | "indeterminate";
+  readonly colSpan: number;
+  readonly hasSelection: boolean;
+  readonly isSelectable: boolean;
+  readonly hasActions: boolean;
+  readonly hasFolderActions: boolean;
+  /**
+   * Whether the current folder has settled with neither folders nor files.
+   * Gated on `initialized` and `loading`, so a view shows the listing, not
+   * the empty state, until the first fetch resolves.
+   */
+  readonly isEmpty: boolean;
+  open(folder: BrowserFolder): void;
+  navigate(index: number): void;
+  sortBy(field: string): void;
+  sortFieldFor(col: BrowserColumn<T>): string;
+  isSorted(col: BrowserColumn<T>): boolean;
+  keyOf(row: T): string;
+  toggleRow(key: string): void;
+  toggleAll(): void;
+  clearSelection(): void;
+  isRowSelected(row: T): boolean;
+  runAction(key: string, row: T): void;
+  runFolderAction(key: string, folder: BrowserFolder): void;
+  runBulkAction(key: string): void;
+  init(): Promise<boolean>;
+  fetch(): Promise<void>;
+  /**
+   * Subscribes a listener to an event. Listeners run in subscription order.
+   * An error in a listener propagates to the caller of the write. Returns a
+   * function that removes the listener.
+   */
+  on<E extends Event<T>>(event: E, listener: Listener<T, E>): () => void;
+};
+/** Default file sort direction. */
+export declare const BROWSER_DEFAULT_SORT_DIRECTION: SortDirection;
+/** The key of the root crumb: the trail's first entry, above every folder. */
+export declare const BROWSER_ROOT_KEY = "";
+/** The label of the root crumb when the config names none. */
+export declare const BROWSER_DEFAULT_ROOT_LABEL = "Home";
+/** The locale cells format in when the config names none. */
+export declare const BROWSER_DEFAULT_LOCALE = "en-US";
+/** The currency code currency cells format in when the config names none. */
+export declare const BROWSER_DEFAULT_CURRENCY = "USD";
+/**
+ * The fields of the container, for key-driven iteration independent of a
+ * container's runtime keys.
+ */
+export declare const BROWSER_STATE_FIELDS: Record<StateKey, null>;
+/**
+ * Builds the initial state container. The result is a plain object. Wrap it
+ * in a reactive proxy to track reads and writes. The trail starts at the
+ * root and sorting starts unset, so no config is needed.
+ */
+export declare const createBrowserState: <T>() => State<T>;
+/**
+ * The headless browser machine. Owns the folder trail, the file sort, and
+ * the file selection; delegates data loading to `wiring.fetch` and joins
+ * the config's action descriptors to the handlers in `wiring`.
+ *
+ * The service reads and writes the `state` container through the `options`
+ * middleware. The container can be a plain object or a reactive proxy; the
+ * service replaces each member as a whole. Each write emits `change`, and
+ * the domain methods emit `updated` and `navigated`. `on` subscribes.
+ */
+export declare class BrowserService<T> implements Service<T> {
+  readonly id: string;
+  readonly config: Config<T>;
+  private readonly wiring;
+  readonly columns: BrowserColumn<T>[];
+  readonly fileKey: keyof T;
+  readonly actions: Service<T>["actions"];
+  readonly folderActions: Service<T>["folderActions"];
+  readonly bulkActions: Service<T>["bulkActions"];
+  private readonly state;
+  private readonly emitter;
+  constructor(id: string, config: Config<T>, state: State<T>, wiring: Actions<T>, options?: Options<T>);
+  on<E extends Event<T>>(event: E, listener: Listener<T, E>): () => void;
+  get folders(): BrowserFolder[];
+  get files(): T[];
+  get loading(): boolean;
+  get initialized(): boolean;
+  get path(): BrowserCrumb[];
+  get sortField(): string | null;
+  get sortDirection(): SortDirection;
+  get selected(): Set<string>;
+  get rootLabel(): string;
+  get locale(): string;
+  get currency(): string;
+  get pathKeys(): string[];
+  get depth(): number;
+  get trail(): BrowserCrumb[];
+  get isAllSelected(): boolean;
+  get isIndeterminate(): boolean;
+  get selectAllState(): boolean | "indeterminate";
+  get colSpan(): number;
+  get hasSelection(): boolean;
+  get isSelectable(): boolean;
+  get hasActions(): boolean;
+  get hasFolderActions(): boolean;
+  get isEmpty(): boolean;
+  keyOf(row: T): string;
+  /** Descends into a folder: push its crumb, drop the selection, refetch. */
+  open(folder: BrowserFolder): void;
+  /**
+   * Jumps to a trail position: `0` is the root, `depth` is where the
+   * browser already stands (a no-op, like clicking the current crumb).
+   */
+  navigate(index: number): void;
+  sortBy(field: string): void;
+  sortFieldFor(col: BrowserColumn<T>): string;
+  isSorted(col: BrowserColumn<T>): boolean;
+  toggleRow(key: string): void;
+  toggleAll(): void;
+  clearSelection(): void;
+  isRowSelected(row: T): boolean;
+  runAction(key: string, row: T): void;
+  runFolderAction(key: string, folder: BrowserFolder): void;
+  runBulkAction(key: string): void;
+  init(): Promise<boolean>;
+  fetch(): Promise<void>;
+}

package/.dist/index.mjs

@@ -0,0 +1,236 @@
+import { entries } from "objectively";
+import { makeEmitter, makeProxy } from "@zoobzio/kit";
+const BROWSER_DEFAULT_SORT_DIRECTION = "asc";
+const BROWSER_ROOT_KEY = "";
+const BROWSER_DEFAULT_ROOT_LABEL = "Home";
+const BROWSER_DEFAULT_LOCALE = "en-US";
+const BROWSER_DEFAULT_CURRENCY = "USD";
+const BROWSER_STATE_FIELDS = {
+	folders: null,
+	files: null,
+	loading: null,
+	initialized: null,
+	path: null,
+	sortField: null,
+	sortDirection: null,
+	selected: null
+};
+const createBrowserState = () => ({
+	folders: [],
+	files: [],
+	loading: false,
+	initialized: false,
+	path: [],
+	sortField: null,
+	sortDirection: "asc",
+	selected: /* @__PURE__ */ new Set()
+});
+const sortFolders = (folders) => [...folders].sort((a, b) => a.label.localeCompare(b.label));
+var BrowserService = class {
+	id;
+	config;
+	wiring;
+	columns;
+	fileKey;
+	actions;
+	folderActions;
+	bulkActions;
+	state;
+	emitter = makeEmitter();
+	constructor(id, config, state, wiring, options = {}) {
+		this.id = id;
+		this.config = config;
+		this.wiring = wiring;
+		this.state = makeProxy(state, BROWSER_STATE_FIELDS, options, this.emitter);
+		this.columns = config.columns;
+		this.fileKey = config.fileKey;
+		this.actions = entries(config.actions ?? {}).map(([key, descriptor]) => ({
+			...descriptor,
+			key,
+			action: (row) => this.runAction(key, row)
+		}));
+		this.folderActions = entries(config.folderActions ?? {}).map(([key, descriptor]) => ({
+			...descriptor,
+			key,
+			action: (folder) => this.runFolderAction(key, folder)
+		}));
+		this.bulkActions = entries(config.bulkActions ?? {}).map(([key, descriptor]) => ({
+			...descriptor,
+			key,
+			action: (selected) => wiring.bulkActions?.[key]?.(selected)
+		}));
+	}
+	on(event, listener) {
+		return this.emitter.on(event, listener);
+	}
+	get folders() {
+		return this.state.folders;
+	}
+	get files() {
+		return this.state.files;
+	}
+	get loading() {
+		return this.state.loading;
+	}
+	get initialized() {
+		return this.state.initialized;
+	}
+	get path() {
+		return this.state.path;
+	}
+	get sortField() {
+		return this.state.sortField;
+	}
+	get sortDirection() {
+		return this.state.sortDirection;
+	}
+	get selected() {
+		return this.state.selected;
+	}
+	get rootLabel() {
+		return this.config.rootLabel ?? "Home";
+	}
+	get locale() {
+		return this.config.locale ?? "en-US";
+	}
+	get currency() {
+		return this.config.currency ?? "USD";
+	}
+	get pathKeys() {
+		return this.path.map((crumb) => crumb.key);
+	}
+	get depth() {
+		return this.path.length;
+	}
+	get trail() {
+		const keys = this.pathKeys;
+		return [{
+			key: "",
+			label: this.rootLabel
+		}, ...this.path.map((crumb, index) => ({
+			key: keys.slice(0, index + 1).join("/"),
+			label: crumb.label
+		}))];
+	}
+	get isAllSelected() {
+		if (!this.files.length) return false;
+		return this.files.every((row) => this.selected.has(this.keyOf(row)));
+	}
+	get isIndeterminate() {
+		if (!this.selected.size) return false;
+		return !this.isAllSelected;
+	}
+	get selectAllState() {
+		if (this.isIndeterminate) return "indeterminate";
+		return this.isAllSelected;
+	}
+	get colSpan() {
+		return this.columns.length + (this.hasActions || this.hasFolderActions ? 1 : 0) + (this.isSelectable ? 1 : 0);
+	}
+	get hasSelection() {
+		return this.selected.size > 0;
+	}
+	get isSelectable() {
+		return this.bulkActions.length > 0;
+	}
+	get hasActions() {
+		return this.actions.length > 0;
+	}
+	get hasFolderActions() {
+		return this.folderActions.length > 0;
+	}
+	get isEmpty() {
+		return this.initialized && !this.loading && !this.folders.length && !this.files.length;
+	}
+	keyOf(row) {
+		return String(row[this.config.fileKey]);
+	}
+	open(folder) {
+		this.state.path = [...this.path, {
+			key: folder.key,
+			label: folder.label
+		}];
+		this.state.selected = /* @__PURE__ */ new Set();
+		this.fetch();
+		this.emitter.emit("navigated", {
+			id: this.id,
+			path: this.pathKeys
+		});
+	}
+	navigate(index) {
+		if (index < 0 || index >= this.depth) return;
+		this.state.path = this.path.slice(0, index);
+		this.state.selected = /* @__PURE__ */ new Set();
+		this.fetch();
+		this.emitter.emit("navigated", {
+			id: this.id,
+			path: this.pathKeys
+		});
+	}
+	sortBy(field) {
+		if (this.sortField === field) this.state.sortDirection = this.sortDirection === "asc" ? "desc" : "asc";
+		else {
+			this.state.sortField = field;
+			this.state.sortDirection = "asc";
+		}
+		this.fetch();
+	}
+	sortFieldFor(col) {
+		return col.sortKey ?? String(col.key);
+	}
+	isSorted(col) {
+		return this.sortField === this.sortFieldFor(col);
+	}
+	toggleRow(key) {
+		const next = new Set(this.selected);
+		if (next.has(key)) next.delete(key);
+		else next.add(key);
+		this.state.selected = next;
+	}
+	toggleAll() {
+		if (this.isAllSelected) this.state.selected = /* @__PURE__ */ new Set();
+		else this.state.selected = new Set(this.files.map((row) => this.keyOf(row)));
+	}
+	clearSelection() {
+		this.state.selected = /* @__PURE__ */ new Set();
+	}
+	isRowSelected(row) {
+		return this.selected.has(this.keyOf(row));
+	}
+	runAction(key, row) {
+		this.wiring.actions?.[key]?.(row);
+	}
+	runFolderAction(key, folder) {
+		this.wiring.folderActions?.[key]?.(folder);
+	}
+	runBulkAction(key) {
+		this.wiring.bulkActions?.[key]?.(this.selected);
+	}
+	async init() {
+		if (this.initialized) return true;
+		this.state.initialized = true;
+		await this.fetch();
+		return true;
+	}
+	async fetch() {
+		this.state.loading = true;
+		try {
+			const result = await this.wiring.fetch({
+				path: this.pathKeys,
+				sortField: this.sortField,
+				sortDirection: this.sortDirection
+			}, this);
+			this.state.folders = sortFolders(result.folders);
+			this.state.files = result.files;
+		} finally {
+			this.state.loading = false;
+			this.emitter.emit("updated", {
+				id: this.id,
+				path: this.pathKeys,
+				folders: this.folders.length,
+				files: this.files.length
+			});
+		}
+	}
+};
+export { BROWSER_DEFAULT_CURRENCY, BROWSER_DEFAULT_LOCALE, BROWSER_DEFAULT_ROOT_LABEL, BROWSER_DEFAULT_SORT_DIRECTION, BROWSER_ROOT_KEY, BROWSER_STATE_FIELDS, BrowserService, createBrowserState };

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Alexander Thorwaldson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,87 @@
-# Temporary Holding Version
+# @zoobzio/browser
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Headless data browser service. Pure TypeScript, no framework dependency.
+
+Owns: the folder trail (open a folder, jump to a crumb), the file sort,
+the file selection, and the join of action descriptors to their handlers.
+Delegates: data loading (`fetch`) and state storage (the container).
+Folders always come back alphabetical; file order is the fetch's.
+
+The package defines its own column and action shapes (`BrowserColumn`,
+`ActionDescriptor`, `FileAction`, `FolderAction`, `BulkAction`,
+`SortDirection`); it depends on no other package.
+
+## Usage
+
+```ts
+import { BrowserService, createBrowserState } from "@zoobzio/browser";
+
+const config = {
+  columns: [{ key: "name", label: "Name", sortable: true }],
+  fileKey: "id",
+  actions: { download: { label: "Download" } },
+};
+
+const browser = new BrowserService("assets", config, createBrowserState(), {
+  fetch: async (params) => api.assets(params), // { folders, files }
+  actions: { download: (file) => save(file) },
+});
+
+await browser.init();
+browser.open({ key: "media", label: "Media" }); // descend, refetch
+browser.navigate(0); // back to the root
+browser.sortBy("name"); // asc, then desc on repeat
+browser.toggleRow("1");
+browser.runAction("download", file); // dispatch a file action by key
+browser.runBulkAction("purge"); // a bulk action over the selection
+```
+
+## The trail
+
+`trail` is the breadcrumb from the root: the root crumb (`rootLabel`,
+default `Home`) followed by one crumb per step of `path`. Each crumb's key
+is its joined path prefix, so keys stay unique when one folder key recurs
+at several depths, and a crumb's index in `trail` is what `navigate` takes.
+
+```ts
+browser.trail; // [{ key: "", label: "Home" }, { key: "media", label: "Media" }]
+browser.navigate(browser.trail.findIndex((c) => c.key === "media"));
+```
+
+## The state container
+
+The service reads and writes the `state` container: the listing, the load
+flags, the trail, the file sort, and the selection. The container can be a
+plain object or a reactive proxy. The service replaces each member as a
+whole, so a proxy tracks every change.
+
+```ts
+createBrowserState(); // plain: tests, Node
+reactive(createBrowserState()); // Vue
+useState(`browser-${id}`, () => createBrowserState()).value; // Nuxt, shared by id
+```
+
+## Middleware
+
+`options.get.state.<field>` and `options.set.state.<field>` receive the value
+of the field and return the value the service uses. A missing slot passes the
+value on.
+
+```ts
+new BrowserService(id, config, state, wiring, {
+  set: { state: { sortField: (field) => field?.toLowerCase() ?? null } },
+});
+```
+
+## Events
+
+`on(event, listener)` subscribes. Listeners run in subscription order, after
+the write lands. The return value removes the listener.
+
+- `change`: a field of the container was written. `{ field, before, after }`, narrowed by `field`.
+- `updated`: a fetch settled, success or failure. `{ id, path, folders, files }` — the key trail and section lengths.
+- `navigated`: the trail changed through `open` or `navigate`. `{ id, path }`.
+
+```ts
+const off = browser.on("navigated", ({ path }) => history.push(path));
+```

package/package.json

@@ -1,6 +1,41 @@
 {
   "name": "@zoobzio/browser",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.0.0",
+  "description": "Headless data browser service: folder trail navigation, file sort, selection, action joins. No framework dependency.",
+  "license": "MIT",
+  "author": {
+    "name": "Alex Thorwaldson",
+    "email": "alex@zoobz.io",
+    "url": "https://zoobz.io"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/zoobzio/foundation.git",
+    "directory": "packages/browser"
+  },
+  "files": [
+    ".dist"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "main": "./.dist/index.mjs",
+  "types": "./.dist/index.d.mts",
+  "exports": {
+    ".": {
+      "types": "./.dist/index.d.mts",
+      "import": "./.dist/index.mjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "dependencies": {
+    "objectively": "^0.3.0",
+    "@zoobzio/kit": "0.0.0"
+  },
+  "scripts": {
+    "build": "obuild",
+    "stub": "obuild --stub",
+    "lint": "oxlint",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run"
+  }
 }