@hanzo/ui 8.0.21 → 8.0.23

package/dist/framework/fields.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Pure mapping between the Hanzo Framework DocType metadata and @hanzo/data's
+ * render model — the brain of the generic DocType renderer. It is the ONE place
+ * that translates the engine's Frappe field vocabulary into @hanzo/data's, so
+ * EVERY app lane (CMS/ERP/CRM/Helpdesk) renders list/form/detail identically with
+ * zero per-doctype code. A new DocType — or a whole new lane — "just works".
+ *
+ * No I/O, no React — data in, data out, trivially testable (the @hanzo/data
+ * imports are `import type`, erased at build, so the unit test runs in plain Node).
+ */
+import type { FieldDefinition, SelectOption } from '@hanzo/data';
+import type { DocField, DocType, FrameworkDoc } from './types';
+/** `first_name` / `firstName` → "First Name"; known acronyms upper-cased. */
+export declare function humanize(name: string): string;
+/** The autoname source field for a `field:xxx` rule (`""` otherwise). */
+export declare function autonameSource(dt: DocType): string;
+export interface FieldMapOpts {
+    /** Editing an existing record: the autoname-source field is fixed (the URL key). */
+    editing?: boolean;
+}
+/**
+ * Map a DocType's fields to the ordered `FieldDefinition[]` every @hanzo/data view
+ * renders from. Hidden fields are dropped; the engine's readOnly is honored; and
+ * when editing an existing record the autoname source (e.g. `slug`) is made
+ * read-only because it IS the document's immutable URL key.
+ */
+export declare function docTypeToFields(dt: DocType, opts?: FieldMapOpts): FieldDefinition[];
+/** The status field a publishable content type uses (a Select including "Published"). */
+export declare function statusField(dt: DocType): string;
+/** Fields shown as table columns: the `inListView` subset (all, if none flagged). */
+export declare function listHiddenFields(dt: DocType): string[];
+/** True when a DocType is a media/asset library (a required Attach) → grid view. */
+export declare function isMediaDoctype(dt: DocType): boolean;
+/** The primary Attach field name (the asset URL) of a media doctype. */
+export declare function mediaFileField(dt: DocType): string;
+/** DocTypes belonging to an app lane (module) — a CMS "collection" is one of these. */
+export declare function moduleDoctypes(dts: DocType[], module: string): DocType[];
+/** The conventional field a collection uses to scope documents to a project. */
+export declare const PROJECT_FIELD = "project";
+/** True when a DocType declares the `project` scope field (→ project filtering works). */
+export declare function hasProjectField(dt: DocType): boolean;
+/** A record's human title — the DocType's titleField, else its name. */
+export declare function titleOf(doc: Record<string, unknown>, dt: DocType): string;
+/**
+ * URL-safe slug from arbitrary text: lower-case, any run of non-alphanumerics
+ * collapsed to a single dash, ends trimmed. Guarantees a no-space, `%`-free
+ * document name (the engine and the console's own proxy path both require it).
+ */
+export declare function slugify(s: unknown): string;
+/** Valid Pascal/slug DocType name (letters/digits/dash/underscore, alnum-led, no space). */
+export declare function isValidDoctypeName(name: string): boolean;
+/**
+ * A framework document → a flat @hanzo/data record: the field values coerced to
+ * their display shapes, plus `id` (the record key every view uses) and the managed
+ * envelope. The ONE read mapping every DocType view shares.
+ */
+export declare function toRecord(doc: FrameworkDoc, dt: DocType): Record<string, unknown>;
+/**
+ * Enrich a record's Link values with the target's human label ({id,label}), so a
+ * relation renders as its title (not a raw id) in BOTH the list cell and the
+ * detail — @hanzo/data's relation display reads `.label`, its input reads `.id`.
+ * `optionsByField` is the loaded picker options per Link field (value=id, label=title).
+ */
+export declare function enrichLinks(record: Record<string, unknown>, dt: DocType, optionsByField: Record<string, SelectOption[]>): Record<string, unknown>;
+/** The Link fields of a DocType (their options must be loaded for the picker). */
+export declare function linkFields(dt: DocType): DocField[];
+/** A blank create-form draft seeded with each field's declared default (Check → bool). */
+export declare function newDraft(dt: DocType): Record<string, unknown>;
+/**
+ * A draft record → the framework write body: editable field values only (the
+ * engine owns `name`/`docstatus`/timestamps), each coerced to its wire shape, and
+ * the autoname source (e.g. `slug`) slugified so the document name is always URL-
+ * safe. Fields left `undefined` are dropped — a partial edit never nulls a value.
+ */
+export declare function savePayload(draft: Record<string, unknown>, dt: DocType): Record<string, unknown>;

package/dist/framework/index.d.ts

@@ -0,0 +1,23 @@
+/**
+ * `@hanzo/ui/framework` — the generic renderer for the Hanzo Framework DocType
+ * engine (cloud `clients/framework`, /v1/framework/*).
+ *
+ * The engine's thesis is that a business app IS a set of DocTypes: an ERP Sales
+ * Order, a CRM Deal, a CMS Page and a Helpdesk Ticket differ only in metadata.
+ * This module is the other half of that thesis — ONE list, ONE detail, ONE form,
+ * driven entirely by that metadata, so every lane renders with zero per-app UI.
+ *
+ * Three seams keep it host-agnostic:
+ *   • `Transport` — how a host reaches /v1/framework (BFF proxy vs IAM bearer).
+ *   • `renderBuilder` — schema AUTHORING, which only an admin surface offers.
+ *   • `renderMedia` — an asset gallery, which needs the host's object store.
+ * Anything a host does not supply is simply not offered; nothing is faked.
+ */
+export * from './types';
+export * from './fields';
+export * from './client';
+export * from './data';
+export { Loader } from './Loader';
+export { CollectionsBrowser, type CollectionsBrowserProps } from './CollectionsBrowser';
+export { DocTypeRecords, type DocTypeRecordsProps } from './DocTypeRecords';
+export { DocTypeDetail, type DocTypeDetailProps } from './DocTypeDetail';

package/dist/framework/types.d.ts

@@ -0,0 +1,81 @@
+/**
+ * The Hanzo Framework wire types — the DocType/DocField/document contract the
+ * cloud `clients/framework` engine serves at /v1/framework/* (Frappe's DocType
+ * metadata core, rebuilt native in Go). These mirror the Go JSON tags exactly.
+ *
+ * This is the ONE metadata vocabulary the generic @hanzo/data DocType renderer
+ * builds from, so CMS/ERP/CRM/Helpdesk — all "just DocTypes" on the engine —
+ * render through the SAME components. Types only; no runtime.
+ */
+/** The engine's closed fieldtype set (mirrors clients/framework/doctype.go). */
+export type Fieldtype = 'Data' | 'Int' | 'Float' | 'Currency' | 'Check' | 'Date' | 'Datetime' | 'Text' | 'SmallText' | 'LongText' | 'RichText' | 'Select' | 'Link' | 'Table' | 'Attach' | 'JSON' | 'Password';
+/** One field of a DocType (Frappe's DocField). */
+export interface DocField {
+    fieldname: string;
+    fieldtype: Fieldtype;
+    label?: string;
+    reqd?: boolean;
+    /** Select → newline-separated choices; Link → target DocType; Table → child DocType. */
+    options?: string;
+    default?: string;
+    unique?: boolean;
+    readOnly?: boolean;
+    hidden?: boolean;
+    inListView?: boolean;
+    fetchFrom?: string;
+}
+/** A role's rights on a DocType (Frappe's DocPerm). */
+export interface DocPerm {
+    role: string;
+    read?: boolean;
+    write?: boolean;
+    create?: boolean;
+    delete?: boolean;
+    submit?: boolean;
+    cancel?: boolean;
+}
+/** A DocType definition — per-org metadata. */
+export interface DocType {
+    name: string;
+    module?: string;
+    isSingle?: boolean;
+    isSubmittable?: boolean;
+    autoname?: string;
+    titleField?: string;
+    fields: DocField[];
+    permissions?: DocPerm[];
+    createdAt?: number;
+    updatedAt?: number;
+}
+/** The managed document envelope keys the engine always returns. */
+export interface DocEnvelope {
+    name: string;
+    doctype: string;
+    /** 0 = draft, 1 = submitted, 2 = cancelled. */
+    docstatus: number;
+    createdAt: number;
+    updatedAt: number;
+}
+/** A document: the field data overlaid with the managed envelope keys. */
+export type FrameworkDoc = Record<string, unknown> & DocEnvelope;
+/** A registered app lane and (optionally, per-org) which fixtures are installed. */
+export interface ModuleInfo {
+    module: string;
+    doctypes: string[];
+    installed?: string[];
+}
+/** The result of installing a module into the caller's org. */
+export interface InstallResult {
+    module: string;
+    created: string[];
+    existing: string[];
+}
+/** List query for the generic document surface. */
+export interface ListQuery {
+    filters?: Record<string, string | number | boolean>;
+    fields?: string[];
+    orderBy?: string;
+    limit?: number;
+}
+/** The redacted-Password marker the engine returns for a set secret. */
+export declare const REDACTED_MARKER = "__set__";