opacacms 0.1.7 → 0.1.8

package/dist/schema/collection.d.ts

@@ -1,12 +1,5 @@
 import type { Collection as BaseCollection, IconName } from "../types";
 import type { AccessRules, InferFields } from "./infer";
-/**
- * Factory for creating Collections.
- * Using a class with static methods for better ESM/Turbopack resolution.
- */
-export declare class Collection {
-    static create(slug: string): CollectionBuilder<{}>;
-}
 /**
  * The Fluent API Collection Builder.
  */
@@ -102,3 +95,6 @@ export declare class CollectionBuilder<TFields extends Record<string, any> = {}>
      */
     build(): BaseCollection;
 }
+export declare const Collection: {
+    create: (slug: string) => CollectionBuilder<{}>;
+};

package/dist/schema/fields/index.d.ts

@@ -1,29 +1,4 @@
 import { FieldBuilder } from "./base";
-/**
- * The Field Factory object containing methods to instantiate specific field builders.
- * Using a class with static methods for better ESM/Turbopack resolution.
- */
-export declare class Field {
-    static text: <N extends string>(name: N) => TextFieldBuilder<N>;
-    static slug: <N extends string>(name: N) => SlugFieldBuilder<N>;
-    static textarea: <N extends string>(name: N) => TextAreaFieldBuilder<N>;
-    static number: <N extends string>(name: N) => NumberFieldBuilder<N>;
-    static boolean: <N extends string>(name: N) => BooleanFieldBuilder<N>;
-    static date: <N extends string>(name: N) => DateFieldBuilder<N>;
-    static select: <N extends string>(name: N) => SelectFieldBuilder<N>;
-    static radio: <N extends string>(name: N) => RadioFieldBuilder<N>;
-    static richText: <N extends string>(name: N) => RichTextFieldBuilder<N>;
-    static relationship: <N extends string>(name: N) => RelationshipFieldBuilder<N>;
-    static join: <N extends string>(name: N) => JoinFieldBuilder<N>;
-    static file: <N extends string>(name: N) => FileFieldBuilder<N>;
-    static array: <N extends string>(name: N) => ArrayFieldBuilder<N, any[]>;
-    static group: <N extends string, TSub extends readonly FieldBuilder<any, any, any, any>[]>(name: N, fields?: TSub) => GroupFieldBuilder<N, any, TSub>;
-    static tabs: () => TabsFieldBuilder<[]>;
-    static collapsible: <N extends string, S extends readonly FieldBuilder<any, any, any, any>[]>(fields?: S) => CollapsibleFieldBuilder<ExtractNames<S>, S>;
-    static row: <S extends readonly FieldBuilder<any, any, any, any>[]>(fields?: S) => RowFieldBuilder<S>;
-    static blocks: <N extends string, TSub extends readonly BlockBuilder<any, any, any>[]>(name: N, ...blocks: TSub) => BlocksFieldBuilder<N, TSub>;
-    static block: <N extends string>(slug: N) => BlockBuilder<N, string, any[]>;
-}
 export declare class TextFieldBuilder<TName extends string> extends FieldBuilder<"text", TName, string> {
     constructor(name: TName);
 }
@@ -123,4 +98,28 @@ export declare class BlocksFieldBuilder<TName extends string, TBlocks extends re
     constructor(name: TName);
     blocks<NewBlocks extends readonly BlockBuilder<any, any, any>[]>(...blocks: NewBlocks): BlocksFieldBuilder<TName, NewBlocks>;
 }
+/**
+ * The Field Factory object containing methods to instantiate specific field builders.
+ */
+export declare const Field: {
+    text: <N extends string>(name: N) => TextFieldBuilder<N>;
+    slug: <N extends string>(name: N) => SlugFieldBuilder<N>;
+    textarea: <N extends string>(name: N) => TextAreaFieldBuilder<N>;
+    number: <N extends string>(name: N) => NumberFieldBuilder<N>;
+    boolean: <N extends string>(name: N) => BooleanFieldBuilder<N>;
+    date: <N extends string>(name: N) => DateFieldBuilder<N>;
+    select: <N extends string>(name: N) => SelectFieldBuilder<N>;
+    radio: <N extends string>(name: N) => RadioFieldBuilder<N>;
+    richText: <N extends string>(name: N) => RichTextFieldBuilder<N>;
+    relationship: <N extends string>(name: N) => RelationshipFieldBuilder<N>;
+    join: <N extends string>(name: N) => JoinFieldBuilder<N>;
+    file: <N extends string>(name: N) => FileFieldBuilder<N>;
+    array: <N extends string>(name: N) => ArrayFieldBuilder<N, any[]>;
+    group: <N extends string, TSub extends readonly FieldBuilder<any, any, any, any>[]>(name: N, fields?: TSub) => GroupFieldBuilder<N, any, TSub>;
+    tabs: () => TabsFieldBuilder<[]>;
+    collapsible: <N extends string, S extends readonly FieldBuilder<any, any, any, any>[]>(fields?: S) => CollapsibleFieldBuilder<ExtractNames<S>, S>;
+    row: <S extends readonly FieldBuilder<any, any, any, any>[]>(fields?: S) => RowFieldBuilder<S>;
+    blocks: <N extends string, TSub extends readonly BlockBuilder<any, any, any>[]>(name: N, ...blocks: TSub) => BlocksFieldBuilder<N, TSub>;
+    block: <N extends string>(slug: N) => BlockBuilder<N, string, any[]>;
+};
 export * from "./base";

package/dist/schema/global.d.ts

@@ -1,18 +1,12 @@
 import type { AccessConfig, Global as GlobalType, IconName } from "../types";
 import { type FieldBuilder } from "./fields/base";
 import type { InferFields } from "./infer";
-/**
- * Singleton factory for creating Globals.
- * Using a class with static methods for better ESM/Turbopack resolution.
- */
-export declare class Global {
-    static create(slug: string): GlobalBuilder<{}>;
-}
+export type Global = GlobalType;
 /**
  * A Fluent API Builder for defining OpacaCMS Globals.
  */
 export declare class GlobalBuilder<TFields extends Record<string, any> = {}> {
-    protected config: Partial<GlobalType>;
+    protected config: Partial<Global>;
     protected _fields: FieldBuilder<any, any>[];
     constructor(slug: string);
     /**
@@ -78,5 +72,11 @@ export declare class GlobalBuilder<TFields extends Record<string, any> = {}> {
     /**
      * Compiles the builder down into the raw Global object expected by OpacaCMS.
      */
-    build(): GlobalType;
+    build(): Global;
 }
+/**
+ * Singleton factory for creating Globals.
+ */
+export declare const Global: {
+    create: (slug: string) => GlobalBuilder<{}>;
+};

package/dist/schema/index.d.ts

@@ -1,4 +1,30 @@
-export { Collection, CollectionBuilder } from "./collection";
-export { Field, FieldBuilder } from "./fields/index";
-export { Global, GlobalBuilder } from "./global";
-export type { AccessRules, InferFields } from "./infer";
+import { CollectionBuilder } from "./collection";
+import { FieldBuilder, TextFieldBuilder, SlugFieldBuilder, TextAreaFieldBuilder, NumberFieldBuilder, BooleanFieldBuilder, RichTextFieldBuilder, RelationshipFieldBuilder, JoinFieldBuilder, FileFieldBuilder, ArrayFieldBuilder, GroupFieldBuilder, TabsFieldBuilder, CollapsibleFieldBuilder, RowFieldBuilder, BlockBuilder, BlocksFieldBuilder, VirtualFieldBuilder } from "./fields/index";
+import { GlobalBuilder } from "./global";
+import type { AccessRules, InferFields } from "./infer";
+export declare const Collection: {
+    create: (slug: string) => CollectionBuilder<{}>;
+};
+export declare const Field: {
+    text: <N extends string>(name: N) => TextFieldBuilder<N>;
+    slug: <N extends string>(name: N) => SlugFieldBuilder<N>;
+    textarea: <N extends string>(name: N) => TextAreaFieldBuilder<N>;
+    number: <N extends string>(name: N) => NumberFieldBuilder<N>;
+    boolean: <N extends string>(name: N) => BooleanFieldBuilder<N>;
+    richText: <N extends string>(name: N) => RichTextFieldBuilder<N>;
+    relationship: <N extends string>(name: N) => RelationshipFieldBuilder<N>;
+    join: <N extends string>(name: N) => JoinFieldBuilder<N>;
+    file: <N extends string>(name: N) => FileFieldBuilder<N>;
+    array: <N extends string>(name: N) => ArrayFieldBuilder<N, any[]>;
+    group: <N extends string, TSub extends readonly FieldBuilder<any, any, any, any>[]>(name: N, fields?: TSub) => GroupFieldBuilder<N, any, TSub>;
+    tabs: () => TabsFieldBuilder<[]>;
+    collapsible: <S extends readonly FieldBuilder<any, any, any, any>[]>(fields?: S) => CollapsibleFieldBuilder<any, S>;
+    row: <S extends readonly FieldBuilder<any, any, any, any>[]>(fields?: S) => RowFieldBuilder<S>;
+    blocks: <N extends string, TSub extends readonly BlockBuilder<any, any, any>[]>(name: N, ...blocks: TSub) => BlocksFieldBuilder<N, TSub>;
+    block: <N extends string>(slug: N) => BlockBuilder<N, string, any[]>;
+};
+export declare const Global: {
+    create: (slug: string) => GlobalBuilder<{}>;
+};
+export { CollectionBuilder, FieldBuilder, GlobalBuilder, VirtualFieldBuilder };
+export type { AccessRules, InferFields };

package/dist/schema/index.js

@@ -1,5 +1,550 @@
-import"../chunk-8sqjbsgt.js";
+import { createRequire } from "node:module";
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/schema/fields/base.ts
+class FieldBuilder {
+  type;
+  name;
+  config = {};
+  constructor(type, name) {
+    this.type = type;
+    this.name = name;
+    this.config = { type, name };
+  }
+  label(label) {
+    this.config.label = label;
+    return this;
+  }
+  placeholder(text) {
+    this.config.placeholder = text;
+    return this;
+  }
+  required(val = true) {
+    this.config.required = val;
+    return this;
+  }
+  unique(val = true) {
+    this.config.unique = val;
+    return this;
+  }
+  localized(val = true) {
+    this.config.localized = val;
+    return this;
+  }
+  defaultValue(val) {
+    this.config.defaultValue = val;
+    return this;
+  }
+  validate(fn) {
+    this.config.validate = fn;
+    return this;
+  }
+  access(config) {
+    this.config.access = config;
+    return this;
+  }
+  description(text) {
+    this._ensureAdmin();
+    this.config.admin.description = text;
+    return this;
+  }
+  admin(opts) {
+    this._ensureAdmin();
+    this.config.admin = { ...this.config.admin, ...opts };
+    return this;
+  }
+  hidden(val = true) {
+    this._ensureAdmin();
+    this.config.admin.hidden = val;
+    return this;
+  }
+  readOnly(val = true) {
+    this._ensureAdmin();
+    this.config.admin.readOnly = val;
+    return this;
+  }
+  extend(opts) {
+    this.config = { ...this.config, ...opts };
+    return this;
+  }
+  _ensureAdmin() {
+    if (!this.config.admin) {
+      this.config.admin = {};
+    }
+  }
+  _ensureOptions() {
+    if (!this.config.options) {
+      this.config.options = {};
+    }
+  }
+  build() {
+    return this.config;
+  }
+}
+
+// src/schema/fields/virtual.ts
+class VirtualFieldBuilder extends FieldBuilder {
+  constructor(name) {
+    super("virtual", name);
+  }
+  resolve(fn) {
+    this.config.resolve = fn;
+    return this;
+  }
+  returnType(type) {
+    this.config.returnType = type;
+    return this;
+  }
+}
+
+// src/schema/collection.ts
+class CollectionBuilder {
+  slug;
+  config = {
+    fields: [],
+    timestamps: true
+  };
+  fieldBuilders = [];
+  constructor(slug) {
+    this.slug = slug;
+    this.config.slug = slug;
+  }
+  label(label) {
+    this.config.label = label;
+    return this;
+  }
+  icon(iconName) {
+    this.config.icon = iconName;
+    return this;
+  }
+  useAsTitle(fieldName) {
+    this._ensureAdmin();
+    this.config.admin.useAsTitle = fieldName;
+    return this;
+  }
+  timestamps(val = true) {
+    this.config.timestamps = val;
+    return this;
+  }
+  fields(fields) {
+    const nextBuilder = new CollectionBuilder(this.config.slug);
+    nextBuilder.config = { ...this.config };
+    nextBuilder.fieldBuilders = [...fields];
+    return nextBuilder;
+  }
+  access(rules) {
+    this.config.access = rules;
+    return this;
+  }
+  virtual(name, options) {
+    const builder = new VirtualFieldBuilder(name);
+    if (options.label)
+      builder.label(options.label);
+    if (options.resolve)
+      builder.resolve(options.resolve);
+    if (options.returnType)
+      builder.returnType(options.returnType);
+    const nextBuilder = new CollectionBuilder(this.config.slug);
+    nextBuilder.config = { ...this.config };
+    nextBuilder.fieldBuilders = [...this.fieldBuilders, builder];
+    return nextBuilder;
+  }
+  computed(name, options) {
+    return this.virtual(name, options);
+  }
+  admin(opts) {
+    if (typeof opts === "boolean") {
+      this.config.admin = opts;
+    } else {
+      this.config.admin = { ...this.config.admin, ...opts };
+    }
+    return this;
+  }
+  versions(opts) {
+    this.config.versions = opts;
+    return this;
+  }
+  webhooks(webhooks) {
+    this.config.webhooks = webhooks;
+    return this;
+  }
+  extend(preset) {
+    return this;
+  }
+  _ensureAdmin() {
+    if (!this.config.admin || typeof this.config.admin === "boolean") {
+      this.config.admin = {};
+    }
+  }
+  build() {
+    const compiledFields = this.fieldBuilders.map((builder) => builder.build());
+    return {
+      ...this.config,
+      fields: compiledFields
+    };
+  }
+}
+
+// src/schema/fields/index.ts
+class TextFieldBuilder extends FieldBuilder {
+  constructor(name) {
+    super("text", name);
+  }
+}
+
+class SlugFieldBuilder extends FieldBuilder {
+  constructor(name) {
+    super("slug", name);
+  }
+  from(sourceField) {
+    this.config.from = sourceField;
+    return this;
+  }
+  format(fn) {
+    this.config.format = fn;
+    return this;
+  }
+}
+
+class TextAreaFieldBuilder extends FieldBuilder {
+  constructor(name) {
+    super("textarea", name);
+  }
+}
+
+class NumberFieldBuilder extends FieldBuilder {
+  constructor(name) {
+    super("number", name);
+  }
+  min(val) {
+    this._ensureOptions();
+    this.config.options.min = val;
+    return this;
+  }
+  max(val) {
+    this._ensureOptions();
+    this.config.options.max = val;
+    return this;
+  }
+}
+
+class BooleanFieldBuilder extends FieldBuilder {
+  constructor(name) {
+    super("boolean", name);
+  }
+  display(type) {
+    this._ensureOptions();
+    this.config.options.display = type;
+    return this;
+  }
+}
+
+class RichTextFieldBuilder extends FieldBuilder {
+  constructor(name) {
+    super("richtext", name);
+  }
+  mode(mode) {
+    this._ensureOptions();
+    this.config.options.defaultMode = mode;
+    return this;
+  }
+}
+
+class RelationshipFieldBuilder extends FieldBuilder {
+  constructor(name) {
+    super("relationship", name);
+  }
+  to(collection) {
+    this.config.relationTo = typeof collection === "string" ? collection : collection.slug;
+    return this;
+  }
+  single() {
+    this.config.hasMany = false;
+    return this;
+  }
+  many() {
+    this.config.hasMany = true;
+    return this;
+  }
+  displayField(field) {
+    this.config.displayField = field;
+    return this;
+  }
+}
+
+class FileFieldBuilder extends FieldBuilder {
+  constructor(name) {
+    super("file", name);
+  }
+  bucket(bucketName) {
+    this.config.bucket = bucketName;
+    return this;
+  }
+  allowedmime_types(types) {
+    this._ensureOptions();
+    this.config.options.allowedmime_types = types;
+    return this;
+  }
+  maxSize(bytes) {
+    this._ensureOptions();
+    this.config.options.maxFileSize = bytes;
+    return this;
+  }
+}
+class TabsFieldBuilder extends FieldBuilder {
+  constructor() {
+    super("tabs", "");
+    this.config.tabs = [];
+  }
+  tab(label, ...fields) {
+    this.config.tabs.push({
+      label,
+      fields: fields.map((f) => f.build())
+    });
+    return this;
+  }
+}
+
+class CollapsibleFieldBuilder extends FieldBuilder {
+  constructor(fields) {
+    super("collapsible", "");
+    this.config.fields = fields ? fields.map((f) => f.build()) : [];
+    this._ensureOptions();
+  }
+  initiallyCollapsed(val = true) {
+    this.config.options.initiallyCollapsed = val;
+    return this;
+  }
+  useAsTitle(fieldName) {
+    this.config.options.useAsTitle = fieldName;
+    return this;
+  }
+  fields(...fields) {
+    this.config.fields = fields.map((f) => f.build());
+    return this;
+  }
+}
+
+class JoinFieldBuilder extends FieldBuilder {
+  constructor(name) {
+    super("join", name);
+  }
+  collection(collectionSlug) {
+    this.config.collection = collectionSlug;
+    return this;
+  }
+  on(fieldName) {
+    this.config.on = fieldName;
+    return this;
+  }
+}
+
+class ArrayFieldBuilder extends FieldBuilder {
+  constructor(name) {
+    super("array", name);
+  }
+  of(...fields) {
+    this.config.fields = fields.map((f) => f.build());
+    return this;
+  }
+}
+
+class GroupFieldBuilder extends FieldBuilder {
+  constructor(name, fields) {
+    super("group", name);
+    if (fields) {
+      this.config.fields = fields.map((f) => f.build());
+    }
+  }
+  fields(...fields) {
+    this.config.fields = fields.map((f) => f.build());
+    return this;
+  }
+}
+
+class RowFieldBuilder extends FieldBuilder {
+  constructor(fields) {
+    super("row", "");
+    if (fields) {
+      this.config.fields = fields.map((f) => f.build());
+    }
+  }
+  fields(...fields) {
+    this.config.fields = fields.map((f) => f.build());
+    return this;
+  }
+}
+
+class BlockBuilder {
+  config;
+  constructor(slug) {
+    this.config = { slug, fields: [] };
+  }
+  label(label) {
+    this.config.label = label;
+    return this;
+  }
+  fields(...fields) {
+    this.config.fields = fields.map((f) => f.build());
+    return this;
+  }
+  build() {
+    return this.config;
+  }
+}
+
+class BlocksFieldBuilder extends FieldBuilder {
+  constructor(name) {
+    super("blocks", name);
+  }
+  blocks(...blocks) {
+    this.config.blocks = blocks.map((b) => b.build());
+    return this;
+  }
+}
+
+// src/schema/global.ts
+class GlobalBuilder {
+  config = {};
+  _fields = [];
+  constructor(slug) {
+    this.config.slug = slug;
+    this.config.fields = [];
+    this.config.timestamps = true;
+  }
+  timestamps(enabled = true) {
+    this.config.timestamps = enabled;
+    return this;
+  }
+  label(label) {
+    this.config.label = label;
+    return this;
+  }
+  icon(iconName) {
+    this.config.icon = iconName;
+    return this;
+  }
+  fields(fields) {
+    const nextBuilder = new GlobalBuilder(this.config.slug);
+    nextBuilder.config = { ...this.config };
+    nextBuilder._fields = [...fields];
+    nextBuilder.config.fields = fields.map((f) => f.build());
+    return nextBuilder;
+  }
+  access(rules) {
+    this.config.access = rules;
+    return this;
+  }
+  virtual(name, options) {
+    const builder = new VirtualFieldBuilder(name);
+    if (options.label)
+      builder.label(options.label);
+    if (options.resolve)
+      builder.resolve(options.resolve);
+    if (options.returnType)
+      builder.returnType(options.returnType);
+    const nextBuilder = new GlobalBuilder(this.config.slug);
+    nextBuilder.config = { ...this.config };
+    nextBuilder._fields = [...this._fields, builder];
+    nextBuilder.config.fields = nextBuilder._fields.map((f) => f.build());
+    return nextBuilder;
+  }
+  computed(name, options) {
+    return this.virtual(name, options);
+  }
+  extend(opts) {
+    this.config = { ...this.config, ...opts };
+    return this;
+  }
+  build() {
+    if (!this.config.slug) {
+      throw new Error("Globals must have a slug.");
+    }
+    if (!this.config.fields || this.config.fields.length === 0) {
+      throw new Error(`Global "${this.config.slug}" must have at least one field.`);
+    }
+    return this.config;
+  }
+}
+
+// src/schema/index.ts
+var Collection = {
+  create: (slug) => new CollectionBuilder(slug)
+};
+var Field = {
+  text: (name) => new TextFieldBuilder(name),
+  slug: (name) => new SlugFieldBuilder(name),
+  textarea: (name) => new TextAreaFieldBuilder(name),
+  number: (name) => new NumberFieldBuilder(name),
+  boolean: (name) => new BooleanFieldBuilder(name),
+  richText: (name) => new RichTextFieldBuilder(name),
+  relationship: (name) => new RelationshipFieldBuilder(name),
+  join: (name) => new JoinFieldBuilder(name),
+  file: (name) => new FileFieldBuilder(name),
+  array: (name) => new ArrayFieldBuilder(name),
+  group: (name, fields) => {
+    const builder = new GroupFieldBuilder(name);
+    if (fields)
+      builder.fields(...fields);
+    return builder;
+  },
+  tabs: () => new TabsFieldBuilder,
+  collapsible: (fields) => {
+    return new CollapsibleFieldBuilder(fields);
+  },
+  row: (fields) => {
+    return new RowFieldBuilder(fields);
+  },
+  blocks: (name, ...blocks) => {
+    const builder = new BlocksFieldBuilder(name);
+    builder.blocks(...blocks);
+    return builder;
+  },
+  block: (slug) => new BlockBuilder(slug)
+};
+var Global = {
+  create: (slug) => new GlobalBuilder(slug)
+};
 export {
+  VirtualFieldBuilder,
   GlobalBuilder,
   Global,
   FieldBuilder,