alinea 0.4.2 → 0.5.0

package/dist/alinea.d.ts

@@ -1,4 +1,4 @@
-export { Meta as meta, page, root, schema, type, workspace } from 'alinea/core';
+export { createConfig as config, Meta as meta, page, root, schema, track, type, workspace } from 'alinea/core';
 export type { Infer as infer } from 'alinea/core';
 export { createMediaRoot as media } from 'alinea/core/media/MediaRoot';
 export * from './input.js';

package/dist/alinea.js

@@ -1,15 +1,26 @@
 import "./chunks/chunk-U5RRZUYZ.js";
 
 // src/alinea.ts
-import { Meta, page, root, schema, type, workspace } from "alinea/core";
+import {
+  createConfig,
+  Meta,
+  page,
+  root,
+  schema,
+  track,
+  type,
+  workspace
+} from "alinea/core";
 import { createMediaRoot } from "alinea/core/media/MediaRoot";
 export * from "./input.js";
 export {
+  createConfig as config,
   createMediaRoot as media,
   Meta as meta,
   page,
   root,
   schema,
+  track,
   type,
   workspace
 };

package/dist/backend/Database.js

@@ -365,14 +365,14 @@ ${JSON.stringify(mutation)}`
       hash = hash.update(c);
     const contentHash = hash.digest().toString(16).padStart(8, "0");
     const modifiedAt = await tx(
-      EntryRow().select(EntryRow.modifiedAt).orderBy(EntryRow.modifiedAt.desc()).first()
+      EntryRow().select(EntryRow.modifiedAt).orderBy(EntryRow.modifiedAt.desc()).maybeFirst()
     );
     await tx(AlineaMeta().delete());
     await tx(
       AlineaMeta().insertOne({
         commitHash,
         contentHash,
-        modifiedAt
+        modifiedAt: modifiedAt ?? 0
       })
     );
   }

package/dist/backend/data/MemoryHandler.d.ts

@@ -0,0 +1,3 @@
+import { Database, Handler } from 'alinea/backend';
+import { Config } from 'alinea/core';
+export declare function createMemoryHandler(config: Config, db: Database): Handler;

package/dist/backend/data/MemoryHandler.js

@@ -0,0 +1,67 @@
+import "../../chunks/chunk-U5RRZUYZ.js";
+
+// src/backend/data/MemoryHandler.ts
+import { Handler, JWTPreviews } from "alinea/backend";
+import { createId } from "alinea/core";
+var MemoryApi = class {
+  constructor(config, db) {
+    this.config = config;
+    this.db = db;
+  }
+  drafts = /* @__PURE__ */ new Map();
+  pending = [];
+  async mutate(params) {
+    const mutations = params.mutations.flatMap((mutate) => mutate.meta);
+    const toCommitHash = createId();
+    await this.db.applyMutations(mutations, toCommitHash);
+    this.pending.push({ ...params, toCommitHash });
+    return { commitHash: toCommitHash };
+  }
+  prepareUpload(file) {
+    throw new Error(`Not implemented`);
+  }
+  async revisions(file) {
+    return [];
+  }
+  async revisionData(file, revision) {
+    throw new Error(`Not implemented`);
+  }
+  async getDraft(entryId) {
+    return this.drafts.get(entryId);
+  }
+  async storeDraft(draft) {
+    this.drafts.set(draft.entryId, draft);
+  }
+  async pendingSince(commitHash) {
+    let i = this.pending.length;
+    for (; i >= 0; i--)
+      if (i > 0 && this.pending[i - 1].toCommitHash === commitHash)
+        break;
+    const pending = this.pending.slice(i);
+    if (pending.length === 0)
+      return void 0;
+    return {
+      toCommitHash: pending[pending.length - 1].toCommitHash,
+      mutations: pending.flatMap(
+        (params) => params.mutations.flatMap((mutate) => mutate.meta)
+      )
+    };
+  }
+};
+function createMemoryHandler(config, db) {
+  const api = new MemoryApi(config, db);
+  return new Handler({
+    db,
+    config,
+    target: api,
+    media: api,
+    history: api,
+    drafts: api,
+    pending: api,
+    previews: new JWTPreviews("dev"),
+    previewAuthToken: "dev"
+  });
+}
+export {
+  createMemoryHandler
+};

package/dist/backend/test/Example.d.ts

@@ -1,10 +1,7 @@
 export declare function createExample(): {
     schema: {
         Page: import("alinea/core").Type<{
-            name: import("../../input/path").PathField & import("../../input/text").TextField;
-            name2: import("../../input/text").TextField;
-            title: import("../../input/text").TextField;
-            path: import("../../input/path").PathField;
+            [x: string]: any;
         }>;
         Container: import("alinea/core").Type<{
             title: import("../../input/text").TextField;
@@ -16,10 +13,7 @@ export declare function createExample(): {
         main: import("alinea/core").Workspace<{
             pages: import("alinea/core").Root<{
                 entry1: import("alinea/core").PageSeed<{
-                    name: import("../../input/path").PathField & import("../../input/text").TextField;
-                    name2: import("../../input/text").TextField;
-                    title: import("../../input/text").TextField;
-                    path: import("../../input/path").PathField;
+                    [x: string]: any;
                 }, Record<string, any>>;
                 entry2: import("alinea/core").PageSeed<{
                     title: import("../../input/text").TextField;
@@ -31,10 +25,7 @@ export declare function createExample(): {
             }>;
             multiLanguage: import("alinea/core").Root<{
                 localised1: import("alinea/core").PageSeed<{
-                    name: import("../../input/path").PathField & import("../../input/text").TextField;
-                    name2: import("../../input/text").TextField;
-                    title: import("../../input/text").TextField;
-                    path: import("../../input/path").PathField;
+                    [x: string]: any;
                 }, Record<string, any>>;
                 localised2: import("alinea/core").PageSeed<{
                     title: import("../../input/text").TextField;
@@ -44,7 +35,7 @@ export declare function createExample(): {
                     localised3: any;
                 }>;
             }>;
-            media: import("alinea/core/media/MediaRoot").MediaRoot<{
+            media: import("../../core/media/MediaRoot").MediaRoot<{
                 dir: import("alinea/core").PageSeed<{
                     title: import("../../input/text").TextField;
                     path: import("../../input/path").PathField;

package/dist/backend/test/ExampleTypes.d.ts

@@ -1,6 +1,3 @@
 export declare const TypeWithTabs: import("alinea/core").Type<{
-    name: import("../../input/path").PathField & import("../../input/text").TextField;
-    name2: import("../../input/text").TextField;
-    title: import("../../input/text").TextField;
-    path: import("../../input/path").PathField;
+    [x: string]: any;
 }>;

package/dist/chunks/{chunk-LRUUF55J.js → chunk-B6H4DO6X.js}

@@ -2,7 +2,7 @@
 var package_default = {
   bin: "./dist/cli.js",
   name: "alinea",
-  version: "0.4.2",
+  version: "0.5.0",
   license: "MIT",
   type: "module",
   scripts: {
@@ -41,7 +41,6 @@ var package_default = {
   ],
   workspaces: [
     "apps/web",
-    "apps/demo",
     "apps/dev",
     "src/backend",
     "src/cli",
@@ -71,7 +70,7 @@ var package_default = {
     "@esbx/static": "^0.0.19",
     "@esbx/target": "^0.0.20",
     "@esbx/workspaces": "^0.0.19",
-    "@ladle/react": "^2.15.0",
+    "@ladle/react": "^4.0.1",
     "@types/better-sqlite3": "^7.6.4",
     "@types/fs-extra": "^11.0.1",
     "@types/glob": "^7.1.4",

package/dist/cli/Generate.js

@@ -71,7 +71,7 @@ async function* generate(options) {
       const cms = await loadCMS(context.outDir);
       cms.exportStore(context.outDir, new Uint8Array());
       const fileData = new LocalData({
-        config: cms,
+        config: cms.config,
         fs: fs.promises,
         rootDir,
         dashboardUrl: await options.dashboardUrl
@@ -80,7 +80,7 @@ async function* generate(options) {
         context,
         fileData,
         store,
-        cms,
+        cms.config,
         nextBuild
       )) {
         yield { cms, db, localData: fileData };
@@ -96,7 +96,7 @@ async function* generate(options) {
       }
       if (done) {
         await Promise.all([
-          generatePackage(context, cms),
+          generatePackage(context, cms.config),
           cms.exportStore(context.outDir, exportStore())
         ]);
         break;

package/dist/cli/Serve.js

@@ -1,6 +1,6 @@
 import {
   package_default
-} from "../chunks/chunk-LRUUF55J.js";
+} from "../chunks/chunk-B6H4DO6X.js";
 import "../chunks/chunk-U5RRZUYZ.js";
 
 // src/cli/Serve.ts
@@ -77,16 +77,20 @@ async function serve(options) {
     } else {
       let createBackend2 = function() {
         if (process.env.ALINEA_CLOUD_DEBUG)
-          return createCloudDebugHandler(currentCMS, db, rootDir);
+          return createCloudDebugHandler(currentCMS.config, db, rootDir);
         if (process.env.ALINEA_CLOUD_URL)
-          return createCloudHandler(currentCMS, db, process.env.ALINEA_API_KEY);
+          return createCloudHandler(
+            currentCMS.config,
+            db,
+            process.env.ALINEA_API_KEY
+          );
         return new Handler({
-          config: currentCMS,
+          config: currentCMS.config,
           db,
           target: fileData,
           media: fileData,
           drafts,
-          history: new GitHistory(currentCMS, rootDir),
+          history: new GitHistory(currentCMS.config, rootDir),
           previews: new JWTPreviews("dev"),
           previewAuthToken: "dev"
         });

package/dist/cli/bin.js

@@ -1,6 +1,6 @@
 import {
   package_default
-} from "../chunks/chunk-LRUUF55J.js";
+} from "../chunks/chunk-B6H4DO6X.js";
 import "../chunks/chunk-U5RRZUYZ.js";
 
 // node_modules/mri/lib/index.mjs

package/dist/cli/generate/CompileConfig.js

@@ -54,7 +54,7 @@ function compileConfig({
         setup(build) {
           build.onEnd((res) => {
             if (res.errors.length) {
-              console.log("> config has errors");
+              console.log("> Could not compile Alinea config");
             } else {
               results.emit(res);
               if (!watch)

package/dist/cli/generate/GenerateDashboard.js

@@ -1,6 +1,6 @@
 import {
   package_default
-} from "../../chunks/chunk-LRUUF55J.js";
+} from "../../chunks/chunk-B6H4DO6X.js";
 import {
   __commonJS,
   __toESM

package/dist/cli/generate/LoadConfig.js

@@ -2,7 +2,7 @@ import "../../chunks/chunk-U5RRZUYZ.js";
 
 // src/cli/generate/LoadConfig.ts
 import { CMS } from "alinea/core/CMS";
-import { values } from "alinea/core/util/Objects";
+import { createCMS } from "alinea/core/driver/DefaultDriver";
 import { createRequire } from "node:module";
 import path from "node:path";
 async function loadCMS(outDir) {
@@ -11,10 +11,10 @@ async function loadCMS(outDir) {
   const outFile = `file://${genConfigFile}?${unique}`;
   global.require = createRequire(import.meta.url);
   const exports = await import(outFile);
-  for (const member of values(exports)) {
-    if (member instanceof CMS)
-      return member;
-  }
+  if ("cms" in exports && exports.cms instanceof CMS)
+    return exports.cms;
+  if ("config" in exports)
+    return createCMS(exports.config);
   throw new Error(`No config found in "${genConfigFile}"`);
 }
 export {

package/dist/cli/static/dashboard/dev.js

@@ -1,4 +1,3 @@
-import {CMS} from 'alinea/core'
 import 'alinea/css'
 import {DevDashboard} from 'alinea/dashboard/dev/DevDashboard'
 import {jsx} from 'react/jsx-runtime'
@@ -13,8 +12,7 @@ reactRender(jsx(DevDashboard, {loadConfig}), into)
 
 async function loadConfig() {
   const exports = await import('/config.js?' + Math.random())
-  for (const member of Object.values(exports)) {
-    if (member instanceof CMS) return member
-  }
+  if ('cms' in exports) return exports.cms.config
+  if ('config' in exports) return exports.config
   throw new Error(`No config found in "/config.js"`)
 }

package/dist/cli/util/FindConfigFile.js

@@ -9,7 +9,7 @@ var defaultLocations = [
   "cms",
   "src/cms"
 ];
-var testExtensions = [".js", ".ts", ".tsx", ".jsx"];
+var testExtensions = [".ts", ".tsx", ".js", ".jsx"];
 function findConfigFile(cwd) {
   for (const location of defaultLocations) {
     for (const extension of testExtensions) {

package/dist/cloud/server/CloudAuthServer.js

@@ -3,7 +3,7 @@ import {
 } from "../../chunks/chunk-IKINPSS5.js";
 import {
   package_default
-} from "../../chunks/chunk-LRUUF55J.js";
+} from "../../chunks/chunk-B6H4DO6X.js";
 import "../../chunks/chunk-U5RRZUYZ.js";
 
 // src/cloud/server/CloudAuthServer.ts

package/dist/core/CMS.d.ts

@@ -8,17 +8,17 @@ type Attachment = Workspace | Root;
 export interface CMSApi extends GraphRealmApi {
     resolver(): Promise<Resolver>;
 }
-export declare abstract class CMS extends GraphRealm implements Config, CMSApi {
+export declare abstract class CMS extends GraphRealm implements CMSApi {
     #private;
     dashboard: DashboardConfig;
     graph: Graph;
+    config: Config;
     constructor(config: Config);
     abstract resolver(): Promise<Resolver>;
     abstract exportStore(cwd: string, store: Uint8Array): Promise<void>;
     abstract readStore(): Promise<Store>;
-    get schema(): import("alinea/core").Schema<object>;
+    get schema(): import("alinea/core").Schema<{}>;
     get workspaces(): Record<string, Workspace>;
-    get preview(): string | undefined;
 }
 export declare namespace CMS {
     const Link: unique symbol;

package/dist/core/CMS.js

@@ -2,27 +2,26 @@ import "../chunks/chunk-U5RRZUYZ.js";
 
 // src/core/CMS.ts
 import { CloudAuthView } from "alinea/cloud/view/CloudAuth";
-import { MediaFile, MediaLibrary } from "alinea/core/media/MediaSchema";
+import { createConfig } from "./Config.js";
 import { Graph, GraphRealm } from "./Graph.js";
 import { entries } from "./util/Objects.js";
 var attached = /* @__PURE__ */ new WeakMap();
 var CMS = class extends GraphRealm {
   dashboard;
   graph;
+  config;
   constructor(config) {
-    const withMedia = {
-      ...config,
-      schema: { MediaLibrary, MediaFile, ...config.schema }
-    };
-    super(withMedia, async (params) => {
+    const normalizedConfig = createConfig(config);
+    super(normalizedConfig, async (params) => {
       const cnx = await this.resolver();
       return cnx.resolve(params);
     });
+    this.config = normalizedConfig;
     this.dashboard = {
       auth: CloudAuthView,
       ...config.dashboard
     };
-    this.graph = new Graph(this, async (params) => {
+    this.graph = new Graph(normalizedConfig, async (params) => {
       const { resolve } = await this.resolver();
       return resolve(params);
     });
@@ -46,9 +45,6 @@ var CMS = class extends GraphRealm {
   get workspaces() {
     return this.config.workspaces;
   }
-  get preview() {
-    return this.config.preview;
-  }
 };
 ((CMS2) => {
   CMS2.Link = Symbol.for("@alinea/CMS.Link");

package/dist/core/Config.d.ts

@@ -1,4 +1,6 @@
+import { ComponentType } from 'react';
 import { Auth } from './Auth.js';
+import { Entry } from './Entry.js';
 import { Schema } from './Schema.js';
 import { Type } from './Type.js';
 import { Workspace, WorkspaceData } from './Workspace.js';
@@ -15,11 +17,19 @@ export interface Config {
     schema: Schema;
     /** A record containing workspace configurations */
     workspaces: Record<string, Workspace>;
-    dashboard?: DashboardConfig;
     /** A url which will be embedded in the dashboard for live previews */
-    preview?: string;
+    preview?: string | ComponentType<{
+        entry: Entry;
+        previewToken: string;
+    }>;
     /** Every edit will pass through a draft phase before being published */
     enableDrafts?: boolean;
+    /**
+    publicDir?: string
+    dashboardFile?: string
+    handlerUrl?:
+    */
+    dashboard?: DashboardConfig;
 }
 export declare namespace Config {
     function mainWorkspace(config: Config): WorkspaceData;
@@ -27,4 +37,28 @@ export declare namespace Config {
     function hasAuth(config: Config): boolean;
 }
 /** Create a new config instance */
-export declare function createConfig<Definition extends Config>(definition: Definition): Definition;
+export declare function createConfig<Definition extends Config>(definition: Definition): Definition & {
+    schema: {
+        MediaLibrary: Type<{
+            title: import("../input/text.js").TextField;
+            path: import("../input/path.js").PathField;
+        }>;
+        MediaFile: Type<{
+            title: import("../input/text.js").TextField;
+            path: import("../input/path.js").PathField;
+            location: import("../input/hidden.js").HiddenField<string>;
+            extension: import("../input/hidden.js").HiddenField<string>;
+            size: import("../input/hidden.js").HiddenField<number>;
+            hash: import("../input/hidden.js").HiddenField<string>;
+            width: import("../input/hidden.js").HiddenField<number>;
+            height: import("../input/hidden.js").HiddenField<number>;
+            preview: import("../input/hidden.js").HiddenField<string>;
+            averageColor: import("../input/hidden.js").HiddenField<string>;
+            focus: import("../input/hidden.js").HiddenField<{
+                x: number;
+                y: number;
+            }>;
+            thumbHash: import("../input/hidden.js").HiddenField<string>;
+        }>;
+    };
+};

package/dist/core/Config.js

@@ -1,6 +1,7 @@
 import "../chunks/chunk-U5RRZUYZ.js";
 
 // src/core/Config.ts
+import { MediaSchema } from "alinea/core/media/MediaSchema";
 import { Workspace } from "./Workspace.js";
 var Config;
 ((Config2) => {
@@ -19,7 +20,10 @@ var Config;
   Config2.hasAuth = hasAuth;
 })(Config || (Config = {}));
 function createConfig(definition) {
-  return definition;
+  return {
+    ...definition,
+    schema: { ...MediaSchema, ...definition.schema }
+  };
 }
 export {
   Config,

package/dist/core/Entry.d.ts

@@ -1,11 +1,8 @@
-import { Expand } from 'alinea/core';
-import { EntryRow } from './EntryRow.js';
+import { EntryPhase } from './EntryRow.js';
 import { Target } from './pages/Target.js';
-export type Entry = Expand<EntryRow>;
-export declare const Entry: Target<{
-    data: Record<string, any>;
+export interface Entry {
     entryId: string;
-    phase: import("alinea/core").EntryPhase;
+    phase: EntryPhase;
     title: string;
     type: string;
     seeded: boolean;
@@ -21,10 +18,12 @@ export declare const Entry: Target<{
     locale: string | null;
     modifiedAt: number;
     rowHash: string;
-    fileHash: string;
     active: boolean;
     main: boolean;
     path: string;
+    fileHash: string;
     url: string;
+    data: Record<string, any>;
     searchableText: string;
-}>;
+}
+export declare const Entry: Target<Entry>;

package/dist/core/EntryRow.d.ts

@@ -40,7 +40,7 @@ export declare class EntryTable {
  * Represents an Entry row in the database,
  * field data is available in the data column in JSON format.
  */
-export interface EntryRow<Data = Record<string, any>> extends table<EntryTable> {
+export type EntryRow<Data = Record<string, any>> = table<EntryTable> & {
     data: Data;
-}
-export declare const EntryRow: import("rado").IndexedTable<EntryTable, "url" | "path" | "phase" | "type" | "parentDir" | "childrenDir" | "parent" | "i18nId" | "versionId" | "rowHash" | "fileIdentifier">;
+};
+export declare const EntryRow: import("rado").IndexedTable<EntryTable, "url" | "path" | "rowHash" | "type" | "parent" | "fileIdentifier" | "parentDir" | "childrenDir" | "versionId" | "phase" | "i18nId">;

package/dist/core/Field.d.ts

@@ -1,41 +1,47 @@
 import { LinkResolver } from 'alinea/backend/resolver/LinkResolver';
 import { Expr } from 'alinea/core/pages/Expr';
-import { InputState } from 'alinea/editor';
 import type { ComponentType } from 'react';
 import { Hint } from './Hint.js';
-import { Label } from './Label.js';
 import { Shape } from './Shape.js';
-export interface FieldOptions {
+export interface FieldOptions<Value> {
+    label: string;
+    /** Hide this field in the dashboard */
     hidden?: boolean;
+    /** Mark this field as read-only */
     readOnly?: boolean;
+    /** The initial value of the field */
+    initialValue?: Value;
 }
-export interface FieldMeta<Value, OnChange, Options> {
+export type WithoutLabel<Options extends FieldOptions<any>> = Omit<Options, 'label'>;
+export interface FieldMeta<Value, Mutator, Options extends FieldOptions<Value>> {
     hint: Hint;
-    label: Label;
-    initialValue?: Value;
     options: Options;
-    view?: FieldView<Value, OnChange, Options>;
+    view?: FieldView<Value, Mutator, Options>;
     postProcess?: (value: Value, loader: LinkResolver) => Promise<void>;
 }
-export interface FieldData<Value, OnChange, Options> extends FieldMeta<Value, OnChange, Options> {
-    shape: Shape<Value, OnChange>;
+export interface FieldData<Value, Mutator, Options extends FieldOptions<Value>> extends FieldMeta<Value, Mutator, Options> {
+    shape: Shape<Value, Mutator>;
 }
-export type FieldView<Value, OnChange, Options> = ComponentType<{
-    state: InputState<readonly [Value, OnChange]>;
-    field: Field<Value, OnChange, Options>;
+export type FieldView<Value, Mutator, Options extends FieldOptions<Value>> = ComponentType<{
+    field: Field<Value, Mutator, Options>;
 }>;
-export interface Field<Value, OnChange, Options> extends Expr<Value> {
-    [Field.Data]: FieldData<Value, OnChange, Options>;
+export interface Field<Value, Mutator, Options extends FieldOptions<Value>> extends Expr<Value> {
+    [Field.Data]: FieldData<Value, Mutator, Options>;
+    [Field.Ref]: symbol;
 }
-export declare class Field<Value = unknown, OnChange = unknown, Options = {}> {
-    constructor(data: FieldData<Value, OnChange, Options>);
+export declare class Field<Value = any, Mutator = any, Options extends FieldOptions<Value> = FieldOptions<Value>> {
+    static index: number;
+    constructor(data: FieldData<Value, Mutator, Options>);
 }
 export declare namespace Field {
     const Data: unique symbol;
-    function provideView<Value, OnChange, Options, Factory extends (...args: Array<any>) => Field<Value, OnChange, Options>>(view: FieldView<Value, OnChange, Options>, factory: Factory): Factory;
+    const Ref: unique symbol;
+    function provideView<Value, Mutator, Options extends FieldOptions<Value>, Factory extends (...args: Array<any>) => Field<Value, Mutator, Options>>(view: FieldView<Value, Mutator, Options>, factory: Factory): Factory;
+    function ref(field: Field): symbol;
     function shape(field: Field<any, any>): Shape;
     function hint(field: Field): Hint;
-    function view<Value, OnChange, Options>(field: Field<Value, OnChange, Options>): FieldView<Value, OnChange, Options> | undefined;
-    function options(field: Field): FieldOptions;
+    function label(field: Field): string;
+    function view<Value, Mutator, Options extends FieldOptions<Value>>(field: Field<Value, Mutator, Options>): FieldView<Value, Mutator, Options> | undefined;
+    function options<Value, Options extends FieldOptions<Value>>(field: Field<Value, any, Options>): Options;
     function isField(value: any): value is Field;
 }

package/dist/core/Field.js

@@ -2,16 +2,23 @@ import "../chunks/chunk-U5RRZUYZ.js";
 
 // src/core/Field.ts
 var Field = class _Field {
+  static index = 0;
   constructor(data) {
     this[_Field.Data] = data;
+    this[_Field.Ref] = Symbol(`Field.${data.options.label}.${_Field.index++}`);
   }
 };
 ((Field2) => {
   Field2.Data = Symbol.for("@alinea/Field.Data");
+  Field2.Ref = Symbol.for("@alinea/Field.Self");
   function provideView(view2, factory) {
     return (...args) => new Field2({ ...factory(...args)[Field2.Data], view: view2 });
   }
   Field2.provideView = provideView;
+  function ref(field) {
+    return field[Field2.Ref];
+  }
+  Field2.ref = ref;
   function shape(field) {
     return field[Field2.Data].shape;
   }
@@ -20,6 +27,10 @@ var Field = class _Field {
     return field[Field2.Data].hint;
   }
   Field2.hint = hint;
+  function label(field) {
+    return field[Field2.Data].options.label;
+  }
+  Field2.label = label;
   function view(field) {
     return field[Field2.Data].view;
   }