@blinkk/root-cms 1.0.0-alpha.9 → 1.0.0-beta.0

package/bin/root-cms.js

@@ -0,0 +1,39 @@
+#!/usr/bin/env node
+
+import {createRequire} from 'node:module';
+import path from 'node:path';
+import {fileURLToPath} from 'node:url';
+import {Command} from 'commander';
+import {bgGreen, black} from 'kleur/colors';
+import {createServer as createViteServer} from 'vite';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const require = createRequire(import.meta.url);
+const packageJson = require(path.join(__dirname, '../package.json'));
+
+async function main() {
+  console.log(`🌱 ${bgGreen(black(' root.js cms '))} v${packageJson.version}`);
+
+  // Load cli.js through vite SSR so that things like `import.meta.glob` are
+  // handled properly.
+  // TODO(stevenle): load the vite config from root.config.ts.
+  const viteServer = await createViteServer();
+  const cli = await viteServer.ssrLoadModule(
+    path.resolve(__dirname, '../dist/cli.js')
+  );
+  await viteServer.close();
+
+  const program = new Command('root-cms');
+  program.version(packageJson.version);
+  program
+    .command('init-firebase')
+    .description('inits the firebase project with proper security rules')
+    .action(cli.initFirebase);
+  program
+    .command('generate-types')
+    .description('generates root-cms.d.ts from *.schema.ts in the project')
+    .action(cli.generateTypes);
+  await program.parseAsync(process.argv);
+}
+
+main();

package/dist/app.js

@@ -0,0 +1,190 @@
+// core/app.tsx
+import { render as renderToString } from "preact-render-to-string";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { jsx, jsxs } from "preact/jsx-runtime";
+var __dirname = path.dirname(fileURLToPath(import.meta.url));
+function App(props) {
+  return /* @__PURE__ */ jsxs("html", {
+    children: [
+      /* @__PURE__ */ jsxs("head", {
+        children: [
+          /* @__PURE__ */ jsx("title", {
+            children: props.title
+          }),
+          /* @__PURE__ */ jsx("link", {
+            rel: "preconnect",
+            href: "https://fonts.googleapis.com"
+          }),
+          /* @__PURE__ */ jsx("link", {
+            rel: "preconnect",
+            href: "https://fonts.gstatic.com",
+            crossOrigin: "anonymous"
+          }),
+          /* @__PURE__ */ jsx("link", {
+            rel: "stylesheet",
+            href: "https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700;900&display=swap"
+          }),
+          /* @__PURE__ */ jsx("link", {
+            rel: "stylesheet",
+            href: "https://fonts.googleapis.com/css2?family=Google+Sans:wght@500&display=swap"
+          }),
+          /* @__PURE__ */ jsx("link", {
+            rel: "stylesheet",
+            href: "{CSS_URL}"
+          })
+        ]
+      }),
+      /* @__PURE__ */ jsxs("body", {
+        children: [
+          /* @__PURE__ */ jsx("div", {
+            id: "root",
+            children: /* @__PURE__ */ jsxs("div", {
+              className: "bootstrap",
+              children: [
+                /* @__PURE__ */ jsx("h1", {
+                  className: "bootstrap__loading",
+                  children: "Loading..."
+                }),
+                /* @__PURE__ */ jsx("div", {
+                  className: "bootstrap-error",
+                  children: "If this page fails to load, try a force refresh by holding the shift key while refreshing the page."
+                })
+              ]
+            })
+          }),
+          /* @__PURE__ */ jsx("script", {
+            dangerouslySetInnerHTML: {
+              __html: `window.__ROOT_CTX = ${JSON.stringify(props.ctx)}`
+            }
+          }),
+          /* @__PURE__ */ jsx("script", {
+            type: "module",
+            src: "{JS_URL}"
+          })
+        ]
+      })
+    ]
+  });
+}
+async function renderApp(req, res, options) {
+  const collectionModules = import.meta.glob("/collections/*.schema.ts", {
+    eager: true
+  });
+  const collections = {};
+  Object.keys(collectionModules).forEach((moduleId) => {
+    const collectionId = path.parse(moduleId).base.split(".")[0];
+    const module = collectionModules[moduleId];
+    const collection = module.default;
+    collections[collectionId] = collection;
+  });
+  const rootConfig = options.rootConfig || {};
+  const cmsConfig = options.cmsConfig || {};
+  const ctx = {
+    rootConfig: {
+      projectId: cmsConfig.id || "default",
+      domain: rootConfig.domain || "https://example.com"
+    },
+    firebaseConfig: options.firebaseConfig,
+    collections
+  };
+  const mainHtml = renderToString(/* @__PURE__ */ jsx(App, {
+    title: "Root.js CMS",
+    ctx
+  }));
+  let html = `<!doctype html>
+${mainHtml}`;
+  if (req.viteServer) {
+    const uiCssPath = path.join(__dirname, "ui/ui.css");
+    const uiJsPath = path.join(__dirname, "ui/ui.js");
+    const tpl = html.replace("{CSS_URL}", `/@fs${uiCssPath}`).replace("{JS_URL}", `/@fs${uiJsPath}`);
+    html = await req.viteServer.transformIndexHtml(req.originalUrl, tpl);
+  } else {
+    html = html.replace("{CSS_URL}", "/cms/static/ui.css").replace("{JS_URL}", "/cms/static/ui.js");
+  }
+  res.setHeader("Content-Type", "text/html");
+  res.send(html);
+}
+function SignIn(props) {
+  return /* @__PURE__ */ jsxs("html", {
+    children: [
+      /* @__PURE__ */ jsxs("head", {
+        children: [
+          /* @__PURE__ */ jsx("title", {
+            children: props.title
+          }),
+          /* @__PURE__ */ jsx("link", {
+            rel: "preconnect",
+            href: "https://fonts.googleapis.com"
+          }),
+          /* @__PURE__ */ jsx("link", {
+            rel: "preconnect",
+            href: "https://fonts.gstatic.com",
+            crossOrigin: "anonymous"
+          }),
+          /* @__PURE__ */ jsx("link", {
+            rel: "stylesheet",
+            href: "https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700;900&display=swap"
+          }),
+          /* @__PURE__ */ jsx("link", {
+            rel: "stylesheet",
+            href: "{CSS_URL}"
+          })
+        ]
+      }),
+      /* @__PURE__ */ jsxs("body", {
+        children: [
+          /* @__PURE__ */ jsx("div", {
+            id: "root",
+            children: /* @__PURE__ */ jsxs("div", {
+              className: "bootstrap",
+              children: [
+                /* @__PURE__ */ jsx("h1", {
+                  className: "bootstrap__loading",
+                  children: "Loading..."
+                }),
+                /* @__PURE__ */ jsx("div", {
+                  className: "bootstrap-error",
+                  children: "If this page fails to load, try a force refresh by holding the shift key while refreshing the page."
+                })
+              ]
+            })
+          }),
+          /* @__PURE__ */ jsx("script", {
+            dangerouslySetInnerHTML: {
+              __html: `window.__ROOT_CTX = ${JSON.stringify(props.ctx)}`
+            }
+          }),
+          /* @__PURE__ */ jsx("script", {
+            type: "module",
+            src: "{JS_URL}"
+          })
+        ]
+      })
+    ]
+  });
+}
+async function renderSignIn(req, res, options) {
+  const ctx = { firebaseConfig: options.firebaseConfig };
+  const mainHtml = renderToString(/* @__PURE__ */ jsx(SignIn, {
+    title: "Sign in",
+    ctx
+  }));
+  let html = `<!doctype html>
+${mainHtml}`;
+  if (req.viteServer) {
+    const cssPath = path.join(__dirname, "ui/signin.css");
+    const jsPath = path.join(__dirname, "ui/signin.js");
+    const tpl = html.replace("{CSS_URL}", `/@fs${cssPath}`).replace("{JS_URL}", `/@fs${jsPath}`);
+    html = await req.viteServer.transformIndexHtml(req.originalUrl, tpl);
+  } else {
+    html = html.replace("{CSS_URL}", "/cms/static/signin.css").replace("{JS_URL}", "/cms/static/signin.js");
+  }
+  res.setHeader("Content-Type", "text/html");
+  res.send(html);
+}
+export {
+  renderApp,
+  renderSignIn
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../core/app.tsx"],
  "sourcesContent": ["import {Request, Response} from '@blinkk/root';\nimport {Collection} from './schema.js';\nimport {render as renderToString} from 'preact-render-to-string';\nimport path from 'node:path';\nimport {fileURLToPath} from 'node:url';\n\nconst __dirname = path.dirname(fileURLToPath(import.meta.url));\n\ninterface AppProps {\n  title: string;\n  ctx: any;\n}\n\nfunction App(props: AppProps) {\n  return (\n    <html>\n      <head>\n        <title>{props.title}</title>\n        <link rel=\"preconnect\" href=\"https://fonts.googleapis.com\" />\n        <link\n          rel=\"preconnect\"\n          href=\"https://fonts.gstatic.com\"\n          crossOrigin=\"anonymous\"\n        />\n        <link\n          rel=\"stylesheet\"\n          href=\"https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700;900&display=swap\"\n        />\n        <link\n          rel=\"stylesheet\"\n          href=\"https://fonts.googleapis.com/css2?family=Google+Sans:wght@500&display=swap\"\n        />\n        <link rel=\"stylesheet\" href=\"{CSS_URL}\" />\n      </head>\n      <body>\n        <div id=\"root\">\n          <div className=\"bootstrap\">\n            <h1 className=\"bootstrap__loading\">Loading...</h1>\n            <div className=\"bootstrap-error\">\n              If this page fails to load, try a force refresh by holding the\n              shift key while refreshing the page.\n            </div>\n          </div>\n        </div>\n        <script\n          dangerouslySetInnerHTML={{\n            __html: `window.__ROOT_CTX = ${JSON.stringify(props.ctx)}`,\n          }}\n        />\n        <script type=\"module\" src=\"{JS_URL}\"></script>\n      </body>\n    </html>\n  );\n}\n\nexport async function renderApp(req: Request, res: Response, options: any) {\n  const collectionModules = import.meta.glob('/collections/*.schema.ts', {\n    eager: true,\n  }) as any;\n  const collections: Record<string, Collection> = {};\n  Object.keys(collectionModules).forEach((moduleId: string) => {\n    const collectionId = path.parse(moduleId).base.split('.')[0];\n    const module = collectionModules[moduleId];\n    const collection = module.default as Collection;\n    collections[collectionId] = collection;\n  });\n  const rootConfig = options.rootConfig || {};\n  const cmsConfig = options.cmsConfig || {};\n  const ctx = {\n    rootConfig: {\n      projectId: cmsConfig.id || 'default',\n      domain: rootConfig.domain || 'https://example.com',\n    },\n    firebaseConfig: options.firebaseConfig,\n    collections: collections,\n  };\n  const mainHtml = renderToString(<App title=\"Root.js CMS\" ctx={ctx} />);\n  let html = `<!doctype html>\\n${mainHtml}`;\n  if (req.viteServer) {\n    const uiCssPath = path.join(__dirname, 'ui/ui.css');\n    const uiJsPath = path.join(__dirname, 'ui/ui.js');\n    const tpl = html\n      .replace('{CSS_URL}', `/@fs${uiCssPath}`)\n      .replace('{JS_URL}', `/@fs${uiJsPath}`);\n    html = await req.viteServer!.transformIndexHtml(req.originalUrl, tpl);\n  } else {\n    html = html\n      .replace('{CSS_URL}', '/cms/static/ui.css')\n      .replace('{JS_URL}', '/cms/static/ui.js');\n  }\n  res.setHeader('Content-Type', 'text/html');\n  res.send(html);\n}\n\ninterface SignInProps {\n  title: string;\n  ctx: any;\n}\n\nfunction SignIn(props: SignInProps) {\n  return (\n    <html>\n      <head>\n        <title>{props.title}</title>\n        <link rel=\"preconnect\" href=\"https://fonts.googleapis.com\" />\n        <link\n          rel=\"preconnect\"\n          href=\"https://fonts.gstatic.com\"\n          crossOrigin=\"anonymous\"\n        />\n        <link\n          rel=\"stylesheet\"\n          href=\"https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700;900&display=swap\"\n        />\n        <link rel=\"stylesheet\" href=\"{CSS_URL}\" />\n      </head>\n      <body>\n        <div id=\"root\">\n          <div className=\"bootstrap\">\n            <h1 className=\"bootstrap__loading\">Loading...</h1>\n            <div className=\"bootstrap-error\">\n              If this page fails to load, try a force refresh by holding the\n              shift key while refreshing the page.\n            </div>\n          </div>\n        </div>\n        <script\n          dangerouslySetInnerHTML={{\n            __html: `window.__ROOT_CTX = ${JSON.stringify(props.ctx)}`,\n          }}\n        />\n        <script type=\"module\" src=\"{JS_URL}\"></script>\n      </body>\n    </html>\n  );\n}\nexport async function renderSignIn(req: Request, res: Response, options: any) {\n  const ctx = {firebaseConfig: options.firebaseConfig};\n  const mainHtml = renderToString(<SignIn title=\"Sign in\" ctx={ctx} />);\n  let html = `<!doctype html>\\n${mainHtml}`;\n  if (req.viteServer) {\n    const cssPath = path.join(__dirname, 'ui/signin.css');\n    const jsPath = path.join(__dirname, 'ui/signin.js');\n    const tpl = html\n      .replace('{CSS_URL}', `/@fs${cssPath}`)\n      .replace('{JS_URL}', `/@fs${jsPath}`);\n    html = await req.viteServer!.transformIndexHtml(req.originalUrl, tpl);\n  } else {\n    html = html\n      .replace('{CSS_URL}', '/cms/static/signin.css')\n      .replace('{JS_URL}', '/cms/static/signin.js');\n  }\n  res.setHeader('Content-Type', 'text/html');\n  res.send(html);\n}\n"],
  "mappings": "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",
  "names": []
}


package/dist/cli.js

@@ -0,0 +1,151 @@
+// cli/commands/init-firebase.ts
+async function initFirebase() {
+  console.log("initFirebase()");
+}
+
+// core/typegen.ts
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import { createRequire } from "module";
+var require2 = createRequire(import.meta.url);
+var dom = require2("dts-dom");
+var TEMPLATE = `/** Root.js CMS types. This file is autogenerated. */
+
+export interface RootCMSDoc<Fields extends {}> {
+    /** The id of the doc, e.g. "Pages/foo-bar". */
+    id: string;
+    /** The collection id of the doc, e.g. "Pages". */
+    collectionId: string;
+    /** The slug of the doc, e.g. "foo-bar". */
+    slug: string;
+    /** System-level metadata. */
+    sys: {
+        createdAt: number;
+        createdBy: string;
+        modifiedAt: number;
+        modifiedBy: string;
+        firstPublishedAt?: string;
+        firstPublishedBy?: string;
+        publishedAt?: string;
+        publishedBy?: string;
+    };
+    /** User-entered field values from the CMS. */
+    fields?: Fields;
+}`;
+async function generateSchemaDts(rootDir) {
+  console.log(`generating root-cms.d.ts from ${rootDir}...`);
+  const schemaModules = import.meta.glob("/**/*.schema.ts", {
+    eager: true
+  });
+  const results = [TEMPLATE];
+  for (const fileId in schemaModules) {
+    const schema = schemaModules[fileId].default;
+    results.push(renderSchema(fileId, schema));
+  }
+  const output = results.join("\n\n").replaceAll("/**  ", "/** ").replaceAll("  */", " */").replace(/\r\n|\r|\n/g, "\n");
+  const outputPath = path.resolve(rootDir, "root-cms.d.ts");
+  await fs.writeFile(outputPath, output, "utf-8");
+  console.log("saved root-cms.d.ts");
+}
+function fieldProperty(field) {
+  const prop = dom.create.property(
+    field.id,
+    fieldType(field),
+    dom.DeclarationFlags.Optional
+  );
+  const jsdoc = [];
+  if (field.label) {
+    if (field.help) {
+      jsdoc.push(`${field.label}. ${field.help}`);
+    } else {
+      jsdoc.push(field.label);
+    }
+  }
+  if (field.deprecated) {
+    jsdoc.push("@deprecated");
+  }
+  if (jsdoc.length > 0) {
+    prop.jsDocComment = jsdoc.join("\n");
+  }
+  return prop;
+}
+function fieldType(field) {
+  if (field.type === "array") {
+    return dom.type.array(fieldType(field.of));
+  }
+  if (field.type === "image") {
+    return dom.create.objectType([
+      dom.create.property("src", dom.type.string),
+      dom.create.property(
+        "alt",
+        dom.type.string,
+        dom.DeclarationFlags.Optional
+      ),
+      dom.create.property(
+        "width",
+        dom.type.number,
+        dom.DeclarationFlags.Optional
+      ),
+      dom.create.property(
+        "height",
+        dom.type.number,
+        dom.DeclarationFlags.Optional
+      )
+    ]);
+  }
+  if (field.type === "multiselect") {
+    return dom.type.array(dom.type.string);
+  }
+  if (field.type === "select") {
+    return dom.type.string;
+  }
+  if (field.type === "string") {
+    return dom.type.string;
+  }
+  if (field.type === "object") {
+    const subproperties = (field.fields || []).map((f) => fieldProperty(f));
+    return dom.create.objectType(subproperties);
+  }
+  return dom.type.unknown;
+}
+function renderSchema(fileId, schema) {
+  const jsdoc = `Generated from \`${fileId}\`.`;
+  const id = path.parse(fileId).name.split(".")[0];
+  const fieldsInterface = `${id}Fields`;
+  const fields = dom.create.interface(
+    fieldsInterface,
+    dom.DeclarationFlags.Export
+  );
+  fields.jsDocComment = jsdoc;
+  for (const field of schema.fields) {
+    if (!field.id) {
+      continue;
+    }
+    fields.members.push(fieldProperty(field));
+  }
+  const fieldsTypeOutput = dom.emit(fields, { singleLineJsDocComments: true }).trim();
+  if (fileId.startsWith("/collections/")) {
+    const baseType = dom.create.namedTypeReference("RootCMSDoc");
+    baseType.typeArguments.push(dom.create.namedTypeReference(fieldsInterface));
+    const docType = dom.create.alias(
+      `${id}Doc`,
+      baseType,
+      dom.DeclarationFlags.Export
+    );
+    docType.jsDocComment = jsdoc;
+    const docTypeOutput = dom.emit(docType, { singleLineJsDocComments: true }).trim();
+    return fieldsTypeOutput + "\n\n" + docTypeOutput;
+  }
+  return fieldsTypeOutput;
+}
+
+// cli/commands/generate-types.ts
+async function generateTypes() {
+  const rootDir = process.cwd();
+  generateSchemaDts(rootDir);
+}
+export {
+  generateTypes,
+  initFirebase
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../cli/commands/init-firebase.ts", "../core/typegen.ts", "../cli/commands/generate-types.ts"],
  "sourcesContent": ["export async function initFirebase() {\n  console.log('initFirebase()');\n}\n", "import {promises as fs} from 'node:fs';\nimport path from 'node:path';\nimport {Field, Schema} from './schema.js';\n\n// `dts-dom` has issues with vite bundler, work around with createRequire().\nimport {createRequire} from 'module';\nconst require = createRequire(import.meta.url);\n// import * as dom from 'dts-dom';\nconst dom = require('dts-dom');\n\n// The `dts-dom` package uses 4-space indents, use the same for consistency.\nconst TEMPLATE = `/** Root.js CMS types. This file is autogenerated. */\n\nexport interface RootCMSDoc<Fields extends {}> {\n    /** The id of the doc, e.g. \"Pages/foo-bar\". */\n    id: string;\n    /** The collection id of the doc, e.g. \"Pages\". */\n    collectionId: string;\n    /** The slug of the doc, e.g. \"foo-bar\". */\n    slug: string;\n    /** System-level metadata. */\n    sys: {\n        createdAt: number;\n        createdBy: string;\n        modifiedAt: number;\n        modifiedBy: string;\n        firstPublishedAt?: string;\n        firstPublishedBy?: string;\n        publishedAt?: string;\n        publishedBy?: string;\n    };\n    /** User-entered field values from the CMS. */\n    fields?: Fields;\n}`;\n\n/**\n * Generates a root-cms.d.ts file from the .schema.ts files in the project.\n */\nexport async function generateSchemaDts(rootDir: string) {\n  console.log(`generating root-cms.d.ts from ${rootDir}...`);\n  const schemaModules = import.meta.glob<{default: Schema}>('/**/*.schema.ts', {\n    eager: true,\n  });\n\n  const results = [TEMPLATE];\n  for (const fileId in schemaModules) {\n    const schema = schemaModules[fileId].default;\n    results.push(renderSchema(fileId, schema));\n  }\n\n  const output = results\n    .join('\\n\\n')\n    .replaceAll('/**  ', '/** ')\n    .replaceAll('  */', ' */')\n    .replace(/\\r\\n|\\r|\\n/g, '\\n');\n  const outputPath = path.resolve(rootDir, 'root-cms.d.ts');\n  await fs.writeFile(outputPath, output, 'utf-8');\n  console.log('saved root-cms.d.ts');\n}\n\nfunction fieldProperty(field: Field): dom.PropertyDeclaration {\n  const prop = dom.create.property(\n    field.id!,\n    fieldType(field),\n    dom.DeclarationFlags.Optional\n  );\n  const jsdoc = [];\n  if (field.label) {\n    if (field.help) {\n      jsdoc.push(`${field.label}. ${field.help}`);\n    } else {\n      jsdoc.push(field.label);\n    }\n  }\n  if (field.deprecated) {\n    jsdoc.push('@deprecated');\n  }\n  if (jsdoc.length > 0) {\n    prop.jsDocComment = jsdoc.join('\\n');\n  }\n  return prop;\n}\n\nfunction fieldType(field: Field): dom.Type {\n  if (field.type === 'array') {\n    return dom.type.array(fieldType(field.of));\n  }\n  if (field.type === 'image') {\n    return dom.create.objectType([\n      dom.create.property('src', dom.type.string),\n      dom.create.property(\n        'alt',\n        dom.type.string,\n        dom.DeclarationFlags.Optional\n      ),\n      dom.create.property(\n        'width',\n        dom.type.number,\n        dom.DeclarationFlags.Optional\n      ),\n      dom.create.property(\n        'height',\n        dom.type.number,\n        dom.DeclarationFlags.Optional\n      ),\n    ]);\n  }\n  if (field.type === 'multiselect') {\n    return dom.type.array(dom.type.string);\n  }\n  if (field.type === 'select') {\n    return dom.type.string;\n  }\n  if (field.type === 'string') {\n    return dom.type.string;\n  }\n  if (field.type === 'object') {\n    const subproperties = (field.fields || []).map((f) => fieldProperty(f));\n    return dom.create.objectType(subproperties);\n  }\n  return dom.type.unknown;\n}\n\nfunction renderSchema(fileId: string, schema: Schema): string {\n  const jsdoc = `Generated from \\`${fileId}\\`.`;\n  const id = path.parse(fileId).name.split('.')[0];\n  const fieldsInterface = `${id}Fields`;\n  const fields = dom.create.interface(\n    fieldsInterface,\n    dom.DeclarationFlags.Export\n  );\n  fields.jsDocComment = jsdoc;\n  for (const field of schema.fields) {\n    if (!field.id) {\n      continue;\n    }\n    fields.members.push(fieldProperty(field));\n  }\n\n  const fieldsTypeOutput = dom\n    .emit(fields, {singleLineJsDocComments: true})\n    .trim();\n  if (fileId.startsWith('/collections/')) {\n    const baseType = dom.create.namedTypeReference('RootCMSDoc');\n    baseType.typeArguments.push(dom.create.namedTypeReference(fieldsInterface));\n    const docType = dom.create.alias(\n      `${id}Doc`,\n      baseType,\n      dom.DeclarationFlags.Export\n    );\n    docType.jsDocComment = jsdoc;\n\n    const docTypeOutput = dom\n      .emit(docType, {singleLineJsDocComments: true})\n      .trim();\n    return fieldsTypeOutput + '\\n\\n' + docTypeOutput;\n  }\n  return fieldsTypeOutput;\n}\n", "import {generateSchemaDts} from '../../core/typegen';\n\nexport async function generateTypes() {\n  const rootDir = process.cwd();\n  generateSchemaDts(rootDir);\n}\n"],
  "mappings": "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",
  "names": ["require"]
}


package/dist/core.d.ts

@@ -0,0 +1,218 @@
+import { FunctionalComponent } from 'preact';
+import { RootConfig } from '@blinkk/root';
+import { CMSPlugin } from './plugin.js';
+import 'firebase-admin/auth';
+
+interface CommonFieldProps {
+    type: string;
+    id?: string;
+    label?: string;
+    help?: string;
+    placeholder?: string;
+    default?: any;
+    hidden?: boolean;
+    deprecated?: boolean;
+}
+type StringField = CommonFieldProps & {
+    type: 'string';
+    default?: string;
+    translate?: boolean;
+    variant?: 'input' | 'textarea';
+};
+declare function string(field: Omit<StringField, 'type'>): StringField;
+type NumberField = CommonFieldProps & {
+    type: 'number';
+    default?: number;
+};
+declare function number(field: Omit<NumberField, 'type'>): NumberField;
+type DateField = CommonFieldProps & {
+    type: 'date';
+    default?: string;
+};
+declare function date(field: Omit<DateField, 'type'>): DateField;
+type DateTimeField = CommonFieldProps & {
+    type: 'datetime';
+    default?: string;
+};
+declare function datetime(field: Omit<DateTimeField, 'type'>): DateTimeField;
+type BooleanField = CommonFieldProps & {
+    type: 'boolean';
+    default?: boolean;
+};
+declare function boolean(field: Omit<BooleanField, 'type'>): BooleanField;
+type SelectField = CommonFieldProps & {
+    type: 'select';
+    default?: string;
+    options?: Array<{
+        value: string;
+        label?: string;
+    }> | string[];
+};
+declare function select(field: Omit<SelectField, 'type'>): SelectField;
+type MultiSelectField = Omit<SelectField, 'type'> & {
+    type: 'multiselect';
+    /** Set to `true` to allow users to create arbitrary values. */
+    creatable?: boolean;
+};
+declare function multiselect(field: Omit<MultiSelectField, 'type'>): MultiSelectField;
+type ImageField = CommonFieldProps & {
+    type: 'image';
+};
+declare function image(field: Omit<ImageField, 'type'>): ImageField;
+type ObjectField = CommonFieldProps & {
+    type: 'object';
+    fields: FieldWithId[];
+};
+declare function object(field: Omit<ObjectField, 'type'>): ObjectField;
+type ArrayField = CommonFieldProps & {
+    type: 'array';
+    default?: any[];
+    /**
+     * String format for the preview line of an item in the array. Placeholder
+     * values should use brackets, e.g. `m{_index:02}: {_type}`.
+     *
+     * Multiple values can be provided, in which case the first preview line with
+     * no missing placeholder values will be used.
+     *
+     * System added placeholder values:
+     *
+     * - _index: The 0-based index.
+     * - _index:02: A left-padded version of _index to 2 digits.
+     * - _index:03: A left-padded version of _index to 3 digits.
+     * - _type: For array of one-of fields, the type of the selected field.
+     */
+    preview?: string | string[];
+    of: ObjectLikeField;
+};
+declare function array(field: Omit<ArrayField, 'type'>): ArrayField;
+type OneOfField = CommonFieldProps & {
+    type: 'oneof';
+    types: Schema[];
+};
+declare function oneOf(field: Omit<OneOfField, 'type'>): OneOfField;
+type Field = StringField | NumberField | DateField | DateTimeField | BooleanField | SelectField | MultiSelectField | ImageField | ObjectField | ArrayField | OneOfField;
+/**
+ * Similar to {@link Field} but with a required `id`.
+ * TODO(stevenle): fix this.
+ */
+type FieldWithId = Field;
+type ObjectLikeField = ImageField | ObjectField | OneOfField;
+interface Schema {
+    name: string;
+    description?: string;
+    fields: FieldWithId[];
+}
+declare function defineSchema(schema: Schema): Schema;
+/** Defines the schema for a collection or reusable component. */
+declare const define: typeof defineSchema;
+type Collection = Schema & {
+    /** URL path where the collection serves from. */
+    url?: string;
+    /** Page component to render the collection for instant previews */
+    Component?: FunctionalComponent;
+    /**
+     * Defines the fields to use for document preview. Defaults to "title" and
+     * "image". Use dot notation for nested fields, e.g. "meta.title".
+     */
+    preview?: {
+        title?: string;
+        image?: string;
+    };
+};
+declare function defineCollection(collection: Collection): Collection;
+declare const collection: typeof defineCollection;
+
+type schema_CommonFieldProps = CommonFieldProps;
+type schema_StringField = StringField;
+declare const schema_string: typeof string;
+type schema_NumberField = NumberField;
+declare const schema_number: typeof number;
+type schema_DateField = DateField;
+declare const schema_date: typeof date;
+type schema_DateTimeField = DateTimeField;
+declare const schema_datetime: typeof datetime;
+type schema_BooleanField = BooleanField;
+declare const schema_boolean: typeof boolean;
+type schema_SelectField = SelectField;
+declare const schema_select: typeof select;
+type schema_MultiSelectField = MultiSelectField;
+declare const schema_multiselect: typeof multiselect;
+type schema_ImageField = ImageField;
+declare const schema_image: typeof image;
+type schema_ObjectField = ObjectField;
+declare const schema_object: typeof object;
+type schema_ArrayField = ArrayField;
+declare const schema_array: typeof array;
+type schema_OneOfField = OneOfField;
+declare const schema_oneOf: typeof oneOf;
+type schema_Field = Field;
+type schema_FieldWithId = FieldWithId;
+type schema_ObjectLikeField = ObjectLikeField;
+type schema_Schema = Schema;
+declare const schema_defineSchema: typeof defineSchema;
+declare const schema_define: typeof define;
+type schema_Collection = Collection;
+declare const schema_defineCollection: typeof defineCollection;
+declare const schema_collection: typeof collection;
+declare namespace schema {
+  export {
+    schema_CommonFieldProps as CommonFieldProps,
+    schema_StringField as StringField,
+    schema_string as string,
+    schema_NumberField as NumberField,
+    schema_number as number,
+    schema_DateField as DateField,
+    schema_date as date,
+    schema_DateTimeField as DateTimeField,
+    schema_datetime as datetime,
+    schema_BooleanField as BooleanField,
+    schema_boolean as boolean,
+    schema_SelectField as SelectField,
+    schema_select as select,
+    schema_MultiSelectField as MultiSelectField,
+    schema_multiselect as multiselect,
+    schema_ImageField as ImageField,
+    schema_image as image,
+    schema_ObjectField as ObjectField,
+    schema_object as object,
+    schema_ArrayField as ArrayField,
+    schema_array as array,
+    schema_OneOfField as OneOfField,
+    schema_oneOf as oneOf,
+    schema_Field as Field,
+    schema_FieldWithId as FieldWithId,
+    schema_ObjectLikeField as ObjectLikeField,
+    schema_Schema as Schema,
+    schema_defineSchema as defineSchema,
+    schema_define as define,
+    schema_Collection as Collection,
+    schema_defineCollection as defineCollection,
+    schema_collection as collection,
+  };
+}
+
+/**
+ * Retrieves a doc from Root.js CMS.
+ */
+declare function getDoc<T>(rootConfig: RootConfig, collectionId: string, slug: string, options: {
+    mode: 'draft' | 'published';
+}): Promise<T | null>;
+/**
+ * Walks the data tree and converts any Timestamp objects to millis and any
+ * _array maps to normal arrays.
+ *
+ * E.g.:
+ *
+ * normalizeData({
+ *   sys: {modifiedAt: Timestamp(123)},
+ *   fields: {
+ *     _array: ['asdf'],
+ *     asdf: {title: 'hello'}
+ *   }
+ * })
+ * // => {sys: {modifiedAt: 123}, fields: {foo: [{title: 'hello'}]}}
+ */
+declare function normalizeData(data: any): any;
+declare function getCmsPlugin(rootConfig: RootConfig): CMSPlugin;
+
+export { getCmsPlugin, getDoc, normalizeData, schema };