@tinacms/schema-tools 0.0.0-202222115457

package/CHANGELOG.md

@@ -0,0 +1,31 @@
+# @tinacms/schema-tools
+
+## 0.0.0-202222115457
+### Patch Changes
+
+- abf25c673: The schema can now to used on the frontend (optional for now but will be the main path moving forward).
+  
+  ### How to migrate.
+  
+  If you gone though the `tinacms init` process there should be a file called `.tina/components/TinaProvider`. In that file you can import the schema from `schema.ts` and add it to the TinaCMS wrapper component.
+  
+  ```tsx
+  import TinaCMS from 'tinacms'
+  import schema, { tinaConfig } from '../schema.ts'
+  
+  // Importing the TinaProvider directly into your page will cause Tina to be added to the production bundle.
+  // Instead, import the tina/provider/index default export to have it dynamially imported in edit-moode
+  /**
+   *
+   * @private Do not import this directly, please import the dynamic provider instead
+   */
+  const TinaProvider = ({ children }) => {
+    return (
+      <TinaCMS {...tinaConfig} schema={schema}>
+        {children}
+      </TinaCMS>
+    )
+  }
+  
+  export default TinaProvider
+  ```

package/dist/index.d.ts

@@ -0,0 +1,14 @@
+/**
+Copyright 2021 Forestry.io Holdings, Inc.
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+    http://www.apache.org/licenses/LICENSE-2.0
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+export * from './schema';
+export * from './types';

package/dist/index.js

@@ -0,0 +1,453 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+var __export = (target, all) => {
+  __markAsModule(target);
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __reExport = (target, module2, desc) => {
+  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
+    for (let key of __getOwnPropNames(module2))
+      if (!__hasOwnProp.call(target, key) && key !== "default")
+        __defProp(target, key, { get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable });
+  }
+  return target;
+};
+var __toModule = (module2) => {
+  return __reExport(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", module2 && module2.__esModule && "default" in module2 ? { get: () => module2.default, enumerable: true } : { value: module2, enumerable: true })), module2);
+};
+
+// pnp:/home/runner/work/tinacms/tinacms/packages/@tinacms/schema-tools/src/index.ts
+__export(exports, {
+  TinaSchema: () => TinaSchema,
+  addNamespaceToSchema: () => addNamespaceToSchema,
+  resolveField: () => resolveField,
+  resolveForm: () => resolveForm
+});
+
+// pnp:/home/runner/work/tinacms/tinacms/packages/@tinacms/schema-tools/src/schema/addNamespaceToSchema.ts
+function addNamespaceToSchema(maybeNode, namespace = []) {
+  if (typeof maybeNode === "string") {
+    return maybeNode;
+  }
+  if (typeof maybeNode === "boolean") {
+    return maybeNode;
+  }
+  const newNode = maybeNode;
+  const keys = Object.keys(maybeNode);
+  Object.values(maybeNode).map((m, index) => {
+    const key = keys[index];
+    if (Array.isArray(m)) {
+      newNode[key] = m.map((element) => {
+        if (!element) {
+          return;
+        }
+        if (!element.hasOwnProperty("name")) {
+          return element;
+        }
+        const value = element.name || element.value;
+        return addNamespaceToSchema(element, [...namespace, value]);
+      });
+    } else {
+      if (!m) {
+        return;
+      }
+      if (!m.hasOwnProperty("name")) {
+        newNode[key] = m;
+      } else {
+        newNode[key] = addNamespaceToSchema(m, [...namespace, m.name]);
+      }
+    }
+  });
+  return __spreadProps(__spreadValues({}, newNode), { namespace });
+}
+
+// pnp:/home/runner/work/tinacms/tinacms/packages/@tinacms/schema-tools/src/util/validate.ts
+var yup = __toModule(require("yup"));
+function assertShape(value, yupSchema, errorMessage) {
+  const shape = yupSchema(yup);
+  try {
+    shape.validateSync(value);
+  } catch (e) {
+    const message = errorMessage || `Failed to assertShape - ${e.message}`;
+    throw new Error(message);
+  }
+}
+
+// pnp:/home/runner/work/tinacms/tinacms/packages/@tinacms/schema-tools/src/util/lastItem.ts
+var lastItem = (arr) => {
+  if (typeof arr === "undefined") {
+    throw new Error("Can not call lastItem when arr is undefined");
+  }
+  return arr[arr.length - 1];
+};
+
+// pnp:/home/runner/work/tinacms/tinacms/packages/@tinacms/schema-tools/src/util/namer.ts
+var capitalize = (s) => {
+  if (typeof s !== "string")
+    return "";
+  return s.charAt(0).toUpperCase() + s.slice(1);
+};
+var generateNamespacedFieldName = (names, suffix = "") => {
+  return (suffix ? [...names, suffix] : names).map(capitalize).join("");
+};
+var NAMER = {
+  dataFilterTypeNameOn: (namespace) => {
+    return generateNamespacedFieldName(namespace, "_FilterOn");
+  },
+  dataFilterTypeName: (namespace) => {
+    return generateNamespacedFieldName(namespace, "Filter");
+  },
+  dataMutationTypeNameOn: (namespace) => {
+    return generateNamespacedFieldName(namespace, "_MutationOn");
+  },
+  dataMutationTypeName: (namespace) => {
+    return generateNamespacedFieldName(namespace, "Mutation");
+  },
+  updateName: (namespace) => {
+    return "update" + generateNamespacedFieldName(namespace, "Document");
+  },
+  createName: (namespace) => {
+    return "create" + generateNamespacedFieldName(namespace, "Document");
+  },
+  queryName: (namespace) => {
+    return "get" + generateNamespacedFieldName(namespace, "Document");
+  },
+  generateQueryListName: (namespace) => {
+    return "get" + generateNamespacedFieldName(namespace, "List");
+  },
+  fragmentName: (namespace) => {
+    return generateNamespacedFieldName(namespace, "") + "Parts";
+  },
+  collectionTypeName: (namespace) => {
+    return generateNamespacedFieldName(namespace, "Collection");
+  },
+  documentTypeName: (namespace) => {
+    return generateNamespacedFieldName(namespace, "Document");
+  },
+  dataTypeName: (namespace) => {
+    return generateNamespacedFieldName(namespace, "");
+  },
+  referenceConnectionType: (namespace) => {
+    return generateNamespacedFieldName(namespace, "Connection");
+  },
+  referenceConnectionEdgesTypeName: (namespace) => {
+    return generateNamespacedFieldName(namespace, "ConnectionEdges");
+  }
+};
+
+// pnp:/home/runner/work/tinacms/tinacms/packages/@tinacms/schema-tools/src/schema/TinaSchema.ts
+var TinaSchema = class {
+  constructor(config) {
+    this.config = config;
+    this.getCollectionsByName = (collectionNames) => {
+      return this.schema.collections.filter((collection) => collectionNames.includes(collection.name));
+    };
+    this.getAllCollectionPaths = () => {
+      const paths = this.getCollections().map((collection) => `${collection.path}${collection.match || ""}`);
+      return paths;
+    };
+    this.getCollection = (collectionName) => {
+      const collection = this.schema.collections.find((collection2) => collection2.name === collectionName);
+      if (!collection) {
+        throw new Error(`Expected to find collection named ${collectionName}`);
+      }
+      const extraFields = {};
+      const templateInfo = this.getTemplatesForCollectable(collection);
+      switch (templateInfo.type) {
+        case "object":
+          extraFields["fields"] = templateInfo.template.fields;
+          break;
+        case "union":
+          extraFields["templates"] = templateInfo.templates;
+          break;
+      }
+      return __spreadProps(__spreadValues(__spreadValues({
+        slug: collection.name
+      }, extraFields), collection), {
+        format: collection.format || "md"
+      });
+    };
+    this.getCollections = () => {
+      return this.schema.collections.map((collection) => this.getCollection(collection.name)) || [];
+    };
+    this.getGlobalTemplate = (templateName) => {
+      var _a;
+      const globalTemplate = (_a = this.schema.templates) == null ? void 0 : _a.find((template) => template.name === templateName);
+      if (!globalTemplate) {
+        throw new Error(`Expected to find global template of name ${templateName}`);
+      }
+      return globalTemplate;
+    };
+    this.getCollectionByFullPath = async (filepath) => {
+      const collection = this.getCollections().find((collection2) => {
+        return filepath.replace("\\", "/").startsWith(collection2.path);
+      });
+      if (!collection) {
+        throw new Error(`Unable to find collection for file at ${filepath}`);
+      }
+      return collection;
+    };
+    this.getCollectionAndTemplateByFullPath = (filepath, templateName) => {
+      let template;
+      const collection = this.getCollections().find((collection2) => {
+        return filepath.replace("\\", "/").startsWith(collection2.path);
+      });
+      if (!collection) {
+        throw new Error(`Unable to find collection for file at ${filepath}`);
+      }
+      const templates = this.getTemplatesForCollectable(collection);
+      if (templates.type === "union") {
+        if (templateName) {
+          template = templates.templates.find((template2) => lastItem(template2.namespace) === templateName);
+          if (!template) {
+            throw new Error(`Unable to determine template for item at ${filepath}`);
+          }
+        } else {
+          throw new Error(`Unable to determine template for item at ${filepath}, no template name provided for collection with multiple templates`);
+        }
+      }
+      if (templates.type === "object") {
+        template = templates.template;
+      }
+      if (!template) {
+        throw new Error(`Something went wrong while trying to determine template for ${filepath}`);
+      }
+      return { collection, template };
+    };
+    this.getTemplateForData = ({
+      data,
+      collection
+    }) => {
+      const templateInfo = this.getTemplatesForCollectable(collection);
+      switch (templateInfo.type) {
+        case "object":
+          return templateInfo.template;
+        case "union":
+          assertShape(data, (yup2) => yup2.object({ _template: yup2.string().required() }));
+          const template = templateInfo.templates.find((template2) => template2.namespace[template2.namespace.length - 1] === data._template);
+          if (!template) {
+            throw new Error(`Expected to find template named '${data._template}' for collection '${lastItem(collection.namespace)}'`);
+          }
+          return template;
+      }
+    };
+    this.isMarkdownCollection = (collectionName) => {
+      const collection = this.getCollection(collectionName);
+      const format = collection.format;
+      if (!format) {
+        return true;
+      }
+      if (["markdown", "md"].includes(format)) {
+        return true;
+      }
+      return false;
+    };
+    this.getTemplatesForCollectable = (collection) => {
+      let extraFields = [];
+      if (collection.references) {
+        extraFields = collection.references;
+      }
+      if (collection.fields) {
+        const template = typeof collection.fields === "string" ? this.getGlobalTemplate(collection.fields) : collection;
+        if (typeof template.fields === "string" || typeof template.fields === "undefined") {
+          throw new Error("Exptected template to have fields but none were found");
+        }
+        return {
+          namespace: collection.namespace,
+          type: "object",
+          template: __spreadProps(__spreadValues({}, template), {
+            fields: [...template.fields, ...extraFields]
+          })
+        };
+      } else {
+        if (collection.templates) {
+          return {
+            namespace: collection.namespace,
+            type: "union",
+            templates: collection.templates.map((templateOrTemplateString) => {
+              const template = typeof templateOrTemplateString === "string" ? this.getGlobalTemplate(templateOrTemplateString) : templateOrTemplateString;
+              return __spreadProps(__spreadValues({}, template), {
+                fields: [...template.fields, ...extraFields]
+              });
+            })
+          };
+        } else {
+          throw new Error(`Expected either fields or templates array to be defined on collection ${collection.namespace.join("_")}`);
+        }
+      }
+    };
+    this.schema = config;
+  }
+};
+
+// pnp:/home/runner/work/tinacms/tinacms/packages/@tinacms/schema-tools/src/schema/resolveField.ts
+var resolveField = (_a, schema) => {
+  var _b = _a, { namespace } = _b, field = __objRest(_b, ["namespace"]);
+  var _a2;
+  const extraFields = field.ui || {};
+  switch (field.type) {
+    case "number":
+      return __spreadValues(__spreadValues({
+        component: "number"
+      }, field), extraFields);
+    case "datetime":
+      return __spreadValues(__spreadValues({
+        component: "date"
+      }, field), extraFields);
+    case "boolean":
+      return __spreadValues(__spreadValues({
+        component: "toggle"
+      }, field), extraFields);
+    case "image":
+      return __spreadValues(__spreadValues({
+        component: "image",
+        clearable: true
+      }, field), extraFields);
+    case "string":
+      if (field.options) {
+        if (field.list) {
+          return __spreadProps(__spreadValues(__spreadValues({
+            component: "checkbox-group"
+          }, field), extraFields), {
+            options: field.options
+          });
+        }
+        return __spreadProps(__spreadValues(__spreadValues({
+          component: "select"
+        }, field), extraFields), {
+          options: [{ label: `Choose an option`, value: "" }, ...field.options]
+        });
+      }
+      if (field.list) {
+        return __spreadValues(__spreadValues({
+          component: "list",
+          field: {
+            component: "text"
+          }
+        }, field), extraFields);
+      }
+      return __spreadValues(__spreadValues({
+        component: "text"
+      }, field), extraFields);
+    case "object":
+      const templateInfo = schema.getTemplatesForCollectable(__spreadProps(__spreadValues({}, field), {
+        namespace
+      }));
+      if (templateInfo.type === "object") {
+        return __spreadValues(__spreadProps(__spreadValues({}, field), {
+          component: field.list ? "group-list" : "group",
+          fields: templateInfo.template.fields.map((field2) => resolveField(field2, schema))
+        }), extraFields);
+      } else if (templateInfo.type === "union") {
+        const templates2 = {};
+        const typeMap2 = {};
+        templateInfo.templates.forEach((template) => {
+          const extraFields2 = template.ui || {};
+          const templateName = lastItem(template.namespace);
+          typeMap2[templateName] = NAMER.dataTypeName(template.namespace);
+          templates2[lastItem(template.namespace)] = __spreadValues({
+            label: template.label || templateName,
+            key: templateName,
+            fields: template.fields.map((field2) => resolveField(field2, schema))
+          }, extraFields2);
+          return true;
+        });
+        return __spreadValues(__spreadProps(__spreadValues({}, field), {
+          typeMap: typeMap2,
+          component: field.list ? "blocks" : "not-implemented",
+          templates: templates2
+        }), extraFields);
+      } else {
+        throw new Error(`Unknown object for resolveField function`);
+      }
+    case "rich-text":
+      const templates = {};
+      const typeMap = {};
+      (_a2 = field.templates) == null ? void 0 : _a2.forEach((template) => {
+        if (typeof template === "string") {
+          throw new Error(`Global templates not yet supported for rich-text`);
+        } else {
+          const extraFields2 = template.ui || {};
+          const templateName = lastItem(template.namespace);
+          typeMap[templateName] = NAMER.dataTypeName(template.namespace);
+          templates[lastItem(template.namespace)] = __spreadValues({
+            label: template.label || templateName,
+            key: templateName,
+            inline: template.inline,
+            name: templateName,
+            fields: template.fields.map((field2) => resolveField(field2, schema))
+          }, extraFields2);
+          return true;
+        }
+      });
+      return __spreadValues(__spreadProps(__spreadValues({}, field), {
+        templates: Object.values(templates),
+        component: "rich-text"
+      }), extraFields);
+    case "reference":
+      return __spreadValues(__spreadProps(__spreadValues({}, field), {
+        component: "reference"
+      }), extraFields);
+    default:
+      throw new Error(`Unknown field type ${field.type}`);
+  }
+};
+
+// pnp:/home/runner/work/tinacms/tinacms/packages/@tinacms/schema-tools/src/schema/resolveForm.ts
+var resolveForm = ({
+  collection,
+  basename,
+  template,
+  schema
+}) => {
+  return {
+    id: basename,
+    label: collection.label,
+    name: basename,
+    fields: template.fields.map((field) => {
+      return resolveField(field, schema);
+    })
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TinaSchema,
+  addNamespaceToSchema,
+  resolveField,
+  resolveForm
+});

package/dist/schema/TinaSchema.d.ts

@@ -0,0 +1,80 @@
+/**
+Copyright 2021 Forestry.io Holdings, Inc.
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+    http://www.apache.org/licenses/LICENSE-2.0
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+import { TinaCloudSchemaEnriched, TinaCloudSchemaBase, TinaCloudCollection, Templateable, Collectable, CollectionTemplateable } from '../types';
+declare type Version = {
+    fullVersion: string;
+    major: string;
+    minor: string;
+    patch: string;
+};
+declare type Meta = {
+    flags?: string[];
+};
+/**
+ * TinaSchema is responsible for allowing you to look up certain
+ * properties of the user-provided schema with ease.
+ *
+ */
+export declare class TinaSchema {
+    config: {
+        version?: Version;
+        meta?: Meta;
+    } & TinaCloudSchemaBase;
+    schema: TinaCloudSchemaEnriched;
+    /**
+     *
+     * Create a schema class from a user defined schema object
+     *
+     * @param  {{version?:Version;meta?:Meta}&TinaCloudSchemaBase} config
+     */
+    constructor(config: {
+        version?: Version;
+        meta?: Meta;
+    } & TinaCloudSchemaBase);
+    getCollectionsByName: (collectionNames: string[]) => TinaCloudCollection<true>[];
+    getAllCollectionPaths: () => string[];
+    getCollection: (collectionName: string) => TinaCloudCollection<true>;
+    getCollections: () => TinaCloudCollection<true>[];
+    getGlobalTemplate: (templateName: string) => {
+        label: string;
+        name: string;
+        ui?: object | (import("../types").UIField<any, any> & {
+            previewSrc: string;
+        });
+        fields: import("../types").TinaFieldInner<true>[];
+        namespace: string[];
+    };
+    getCollectionByFullPath: (filepath: string) => Promise<TinaCloudCollection<true>>;
+    getCollectionAndTemplateByFullPath: (filepath: string, templateName?: string) => {
+        collection: TinaCloudCollection<true>;
+        template: Templateable;
+    };
+    getTemplateForData: ({ data, collection, }: {
+        data?: unknown;
+        collection: Collectable;
+    }) => Templateable;
+    isMarkdownCollection: (collectionName: string) => boolean;
+    /**
+     * Gets the template or templates from the item.
+     * Both `object` fields and collections support
+     * the ability for an object to be polymorphic,
+     * and if it is, we need to build unions, which
+     * are more of a headache for non-polymorphic
+     * needs, so we also need the ability to just
+     * build object types
+     *
+     *
+     */
+    getTemplatesForCollectable: (collection: Collectable) => CollectionTemplateable;
+}
+export {};

package/dist/schema/addNamespaceToSchema.d.ts

@@ -0,0 +1,13 @@
+/**
+Copyright 2021 Forestry.io Holdings, Inc.
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+    http://www.apache.org/licenses/LICENSE-2.0
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+export declare function addNamespaceToSchema<T extends object | string>(maybeNode: T, namespace?: string[]): T;

package/dist/schema/index.d.ts

@@ -0,0 +1,16 @@
+/**
+Copyright 2021 Forestry.io Holdings, Inc.
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+    http://www.apache.org/licenses/LICENSE-2.0
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+export * from './addNamespaceToSchema';
+export * from './TinaSchema';
+export * from './resolveField';
+export * from './resolveForm';

package/dist/schema/resolveField.d.ts

@@ -0,0 +1,24 @@
+/**
+Copyright 2021 Forestry.io Holdings, Inc.
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+    http://www.apache.org/licenses/LICENSE-2.0
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+import { TinaFieldEnriched } from '../types';
+import { TinaSchema } from './TinaSchema';
+/**
+ *
+ * Turns a field the schema (schema.{js,ts} file) into a valid front end FieldConfig
+ *
+ *
+ * @param  {TinaFieldEnriched} field. The field that will be transformed
+ * @param  {TinaSchema} schema the entireT Tina Schema
+ * @returns unknown
+ */
+export declare const resolveField: ({ namespace, ...field }: TinaFieldEnriched, schema: TinaSchema) => unknown;

package/dist/schema/resolveForm.d.ts

@@ -0,0 +1,22 @@
+/**
+Copyright 2021 Forestry.io Holdings, Inc.
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+    http://www.apache.org/licenses/LICENSE-2.0
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+import type { ResolveFormArgs } from '../types';
+/**
+ *  Given a collection, basename, template and schema. This will transform the given information into a valid frontend form config
+ */
+export declare const resolveForm: ({ collection, basename, template, schema, }: ResolveFormArgs) => {
+    id: string;
+    label: string;
+    name: string;
+    fields: unknown[];
+};

package/dist/types/SchemaTypes.d.ts

@@ -0,0 +1,342 @@
+/**
+Copyright 2021 Forestry.io Holdings, Inc.
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+    http://www.apache.org/licenses/LICENSE-2.0
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+import { TinaSchema } from '../schema';
+import type { FC } from 'react';
+export declare type UIField<F extends UIField = any, Shape = any> = {
+    label?: string;
+    description?: string;
+    component?: FC<any> | string | null;
+    parse?: (value: Shape, name: string, field: F) => any;
+    format?: (value: Shape, name: string, field: F) => any;
+    validate?(value: Shape, allValues: any, meta: any, field: UIField<F, Shape>): string | object | undefined | void;
+    defaultValue?: Shape;
+};
+export interface TinaCloudSchema<WithNamespace extends boolean> {
+    templates?: GlobalTemplate<WithNamespace>[];
+    collections: TinaCloudCollection<WithNamespace>[];
+}
+export declare type TinaCloudSchemaBase = TinaCloudSchema<false>;
+export declare type TinaCloudSchemaEnriched = TinaCloudSchema<true>;
+/**
+ * As part of the build process, each node is given a `path: string[]` key
+ * to help with namespacing type names, this is added as part of the
+ * createTinaSchema step
+ */
+export interface TinaCloudSchemaWithNamespace {
+    templates?: GlobalTemplate<true>[];
+    collections: TinaCloudCollection<true>[];
+    namespace: string[];
+}
+export declare type TinaCloudCollection<WithNamespace extends boolean> = CollectionFields<WithNamespace> | CollectionTemplates<WithNamespace>;
+export declare type TinaCloudCollectionBase = TinaCloudCollection<false>;
+export declare type TinaCloudCollectionEnriched = TinaCloudCollection<true>;
+declare type FormatType = 'json' | 'md' | 'markdown' | 'mdx';
+interface BaseCollection {
+    label?: string;
+    name: string;
+    path: string;
+    format?: FormatType;
+    match?: string;
+}
+declare type CollectionTemplates<WithNamespace extends boolean> = WithNamespace extends true ? CollectionTemplatesWithNamespace<WithNamespace> : CollectionTemplatesInner<WithNamespace>;
+interface CollectionTemplatesInner<WithNamespace extends boolean> extends BaseCollection {
+    templates: (string | Template<WithNamespace>)[];
+    fields?: undefined;
+}
+export interface CollectionTemplatesWithNamespace<WithNamespace extends boolean> extends BaseCollection {
+    templates: (string | Template<WithNamespace>)[];
+    fields?: undefined;
+    references?: ReferenceType<WithNamespace>[];
+    namespace: WithNamespace extends true ? string[] : undefined;
+}
+declare type CollectionFields<WithNamespace extends boolean> = WithNamespace extends true ? CollectionFieldsWithNamespace<WithNamespace> : CollectionFieldsInner<WithNamespace>;
+export interface CollectionFieldsWithNamespace<WithNamespace extends boolean> extends BaseCollection {
+    fields: string | TinaFieldInner<WithNamespace>[];
+    templates?: undefined;
+    references?: ReferenceType<WithNamespace>[];
+    namespace: string[];
+}
+interface CollectionFieldsInner<WithNamespace extends boolean> extends BaseCollection {
+    fields: string | TinaFieldInner<WithNamespace>[];
+    templates?: undefined;
+}
+export declare type TinaFieldInner<WithNamespace extends boolean> = ScalarType<WithNamespace> | ObjectType<WithNamespace> | ReferenceType<WithNamespace> | RichType<WithNamespace>;
+export declare type TinaFieldBase = TinaFieldInner<false>;
+export declare type TinaFieldEnriched = TinaFieldInner<true>;
+interface TinaField {
+    name: string;
+    label?: string;
+    description?: string;
+    required?: boolean;
+    /**
+     * Any items passed to the UI field will be passed to the underlying field.
+     * NOTE: only serializable values are supported, so functions like `validate`
+     * will be ignored.
+     */
+    ui?: object;
+}
+declare type ScalarType<WithNamespace extends boolean> = WithNamespace extends true ? ScalarTypeWithNamespace : ScalarTypeInner;
+declare type Option = string | {
+    label: string;
+    value: string;
+};
+declare type ScalarTypeInner = TinaField & TinaScalarField & {
+    options?: Option[];
+};
+declare type ScalarTypeWithNamespace = TinaField & TinaScalarField & {
+    options?: Option[];
+    namespace: string[];
+};
+declare type TinaScalarField = StringField | BooleanField | DateTimeField | NumberField | ImageField;
+declare type StringField = {
+    type: 'string';
+    isBody?: boolean;
+    list?: false;
+    ui?: UIField<any, string>;
+} | {
+    type: 'string';
+    isBody?: boolean;
+    list: true;
+    ui?: UIField<any, string[]>;
+};
+declare type BooleanField = {
+    type: 'boolean';
+    list?: false;
+    ui?: object | UIField<any, boolean>;
+} | {
+    type: 'boolean';
+    list: true;
+    ui?: object | UIField<any, boolean[]>;
+};
+declare type NumberField = {
+    type: 'number';
+    list?: false;
+    ui?: object | UIField<any, number>;
+} | {
+    type: 'number';
+    list: true;
+    ui?: object | UIField<any, number[]>;
+};
+declare type DateTimeField = {
+    type: 'datetime';
+    dateFormat?: string;
+    timeFormat?: string;
+    list?: false;
+    ui?: object | UIField<any, string>;
+} | {
+    type: 'datetime';
+    dateFormat?: string;
+    timeFormat?: string;
+    list: true;
+    ui?: object | UIField<any, string[]>;
+};
+declare type ImageField = {
+    type: 'image';
+    list?: false;
+    ui?: object | UIField<any, string>;
+} | {
+    type: 'image';
+    list: true;
+    ui?: object | UIField<any, string[]>;
+};
+export declare type ReferenceType<WithNamespace extends boolean> = WithNamespace extends true ? ReferenceTypeWithNamespace : ReferenceTypeInner;
+export declare type RichType<WithNamespace extends boolean> = WithNamespace extends true ? RichTypeWithNamespace : RichTypeInner;
+export interface ReferenceTypeInner extends TinaField {
+    type: 'reference';
+    list?: boolean;
+    reverseLookup?: {
+        label: string;
+        name: string;
+    };
+    collections: string[];
+}
+export interface ReferenceTypeWithNamespace extends TinaField {
+    type: 'reference';
+    list?: boolean;
+    collections: string[];
+    reverseLookup?: {
+        label: string;
+        name: string;
+    };
+    namespace: string[];
+}
+export interface RichTypeWithNamespace extends TinaField {
+    type: 'rich-text';
+    namespace: string[];
+    isBody?: boolean;
+    list?: boolean;
+    templates?: (string | (Template<true> & {
+        inline?: boolean;
+    }))[];
+}
+export interface RichTypeInner extends TinaField {
+    type: 'rich-text';
+    isBody?: boolean;
+    list?: boolean;
+    templates?: (string | (Template<false> & {
+        inline?: boolean;
+    }))[];
+}
+export declare type ObjectType<WithNamespace extends boolean> = ObjectTemplates<WithNamespace> | ObjectFields<WithNamespace>;
+declare type ObjectTemplates<WithNamespace extends boolean> = WithNamespace extends true ? ObjectTemplatesWithNamespace<WithNamespace> : ObjectTemplatesInner<WithNamespace>;
+declare type ObjectTemplatesInner<WithNamespace extends boolean> = ObjectTemplatesInnerWithList<WithNamespace> | ObjectTemplatesInnerWithoutList<WithNamespace>;
+interface ObjectTemplatesInnerWithList<WithNamespace extends boolean> extends ObjectTemplatesInnerBase<WithNamespace> {
+    list?: true;
+    ui?: object | ({
+        itemProps?(item: Record<string, any>): {
+            key?: string;
+            label?: string;
+        };
+    } & UIField<any, string>);
+}
+interface ObjectTemplatesInnerWithoutList<WithNamespace extends boolean> extends ObjectTemplatesInnerBase<WithNamespace> {
+    list?: false;
+    ui?: object | UIField<any, string>;
+}
+interface ObjectTemplatesInnerBase<WithNamespace extends boolean> extends TinaField {
+    type: 'object';
+    visualSelector?: boolean;
+    required?: false;
+    list?: boolean;
+    /**
+     * templates can either be an array of Tina templates or a reference to
+     * global template definition.
+     *
+     * You should use `templates` when your object can be any one of multiple shapes (polymorphic)
+     *
+     * You can only provide one of `fields` or `template`, but not both
+     */
+    templates: (string | Template<WithNamespace>)[];
+    fields?: undefined;
+}
+interface ObjectTemplatesWithNamespace<WithNamespace extends boolean> extends TinaField {
+    type: 'object';
+    visualSelector?: boolean;
+    required?: false;
+    list?: boolean;
+    /**
+     * templates can either be an array of Tina templates or a reference to
+     * global template definition.
+     *
+     * You should use `templates` when your object can be any one of multiple shapes (polymorphic)
+     *
+     * You can only provide one of `fields` or `template`, but not both
+     */
+    templates: (string | Template<WithNamespace>)[];
+    fields?: undefined;
+    namespace: WithNamespace extends true ? string[] : undefined;
+}
+declare type ObjectFields<WithNamespace extends boolean> = WithNamespace extends true ? InnerObjectFieldsWithNamespace<WithNamespace> : InnerObjectFields<WithNamespace>;
+interface InnerObjectFields<WithNamespace extends boolean> extends TinaField {
+    type: 'object';
+    visualSelector?: boolean;
+    required?: false;
+    /**
+     * fields can either be an array of Tina fields, or a reference to the fields
+     * of a global template definition.
+     *
+     * You can only provide one of `fields` or `templates`, but not both.
+     */
+    fields: string | TinaFieldInner<WithNamespace>[];
+    templates?: undefined;
+    list?: boolean;
+}
+interface InnerObjectFieldsWithNamespace<WithNamespace extends boolean> extends TinaField {
+    type: 'object';
+    visualSelector?: boolean;
+    required?: false;
+    /**
+     * fields can either be an array of Tina fields, or a reference to the fields
+     * of a global template definition.
+     *
+     * You can only provide one of `fields` or `templates`, but not both.
+     */
+    fields: string | TinaFieldInner<WithNamespace>[];
+    templates?: undefined;
+    namespace: WithNamespace extends true ? string[] : undefined;
+    list?: boolean;
+}
+/**
+ * Global Templates are defined once, and can be used anywhere by referencing the 'name' of the template
+ *
+ * TODO: ensure we don't permit infite loop with self-references
+ */
+export declare type GlobalTemplate<WithNamespace extends boolean> = WithNamespace extends true ? {
+    label: string;
+    name: string;
+    ui?: object | (UIField<any, any> & {
+        previewSrc: string;
+    });
+    fields: TinaFieldInner<WithNamespace>[];
+    namespace: WithNamespace extends true ? string[] : undefined;
+} : {
+    label: string;
+    name: string;
+    ui?: object | (UIField<any, any> & {
+        previewSrc: string;
+    });
+    fields: TinaFieldInner<WithNamespace>[];
+};
+export declare type TinaCloudTemplateBase = GlobalTemplate<false>;
+export declare type TinaCloudTemplateEnriched = GlobalTemplate<true>;
+/**
+ * Templates allow you to define an object as polymorphic
+ */
+export declare type Template<WithNamespace extends boolean> = WithNamespace extends true ? {
+    label: string;
+    name: string;
+    fields: TinaFieldInner<WithNamespace>[];
+    ui?: object | (UIField<any, any> & {
+        previewSrc: string;
+    });
+    namespace: WithNamespace extends true ? string[] : undefined;
+} : {
+    label: string;
+    name: string;
+    ui?: object | (UIField<any, any> & {
+        previewSrc: string;
+    });
+    fields: TinaFieldInner<WithNamespace>[];
+};
+export declare type CollectionTemplateableUnion = {
+    namespace: string[];
+    type: 'union';
+    templates: Templateable[];
+};
+export declare type CollectionTemplateableObject = {
+    namespace: string[];
+    type: 'object';
+    visualSelector?: boolean;
+    required?: false;
+    template: Templateable;
+};
+export declare type CollectionTemplateable = CollectionTemplateableUnion | CollectionTemplateableObject;
+export declare type Collectable = {
+    namespace: string[];
+    templates?: (string | Templateable)[];
+    fields?: string | TinaFieldEnriched[];
+    references?: ReferenceType<true>[];
+};
+export declare type Templateable = {
+    name: string;
+    namespace: string[];
+    fields: TinaFieldEnriched[];
+    ui?: object;
+};
+export declare type ResolveFormArgs = {
+    collection: TinaCloudCollection<true>;
+    basename: string;
+    template: Templateable;
+    schema: TinaSchema;
+};
+export {};

package/dist/types/index.d.ts

@@ -0,0 +1,18 @@
+/**
+
+Copyright 2021 Forestry.io Holdings, Inc.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+*/
+export * from './SchemaTypes';

package/dist/util/index.d.ts

@@ -0,0 +1,16 @@
+/**
+Copyright 2021 Forestry.io Holdings, Inc.
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+    http://www.apache.org/licenses/LICENSE-2.0
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+export * from './validate';
+export * from './lastItem';
+export * from './namer';
+export * from './sequential';

package/dist/util/lastItem.d.ts

@@ -0,0 +1,13 @@
+/**
+Copyright 2021 Forestry.io Holdings, Inc.
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+    http://www.apache.org/licenses/LICENSE-2.0
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+export declare const lastItem: (arr: (number | string)[]) => string | number;

package/dist/util/namer.d.ts

@@ -0,0 +1,28 @@
+/**
+Copyright 2021 Forestry.io Holdings, Inc.
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+    http://www.apache.org/licenses/LICENSE-2.0
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+export declare const NAMER: {
+    dataFilterTypeNameOn: (namespace: string[]) => string;
+    dataFilterTypeName: (namespace: string[]) => string;
+    dataMutationTypeNameOn: (namespace: string[]) => string;
+    dataMutationTypeName: (namespace: string[]) => string;
+    updateName: (namespace: string[]) => string;
+    createName: (namespace: string[]) => string;
+    queryName: (namespace: string[]) => string;
+    generateQueryListName: (namespace: string[]) => string;
+    fragmentName: (namespace: string[]) => string;
+    collectionTypeName: (namespace: string[]) => string;
+    documentTypeName: (namespace: string[]) => string;
+    dataTypeName: (namespace: string[]) => string;
+    referenceConnectionType: (namespace: string[]) => string;
+    referenceConnectionEdgesTypeName: (namespace: string[]) => string;
+};

package/dist/util/sequential.d.ts

@@ -0,0 +1,23 @@
+/**
+Copyright 2021 Forestry.io Holdings, Inc.
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+    http://www.apache.org/licenses/LICENSE-2.0
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+/**
+ * Iterate through an array of promises sequentially, ensuring the order
+ * is preserved.
+ *
+ * ```js
+ * await sequential(templates, async (template) => {
+ *   await doSomething(template)
+ * })
+ * ```
+ */
+export declare const sequential: <A, B>(items: A[], callback: (args: A, idx: number) => Promise<B>) => Promise<B[]>;

package/dist/util/validate.d.ts

@@ -0,0 +1,15 @@
+/**
+Copyright 2021 Forestry.io Holdings, Inc.
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+    http://www.apache.org/licenses/LICENSE-2.0
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+import * as yup from 'yup';
+import type { Schema } from 'yup';
+export declare function assertShape<T extends unknown>(value: unknown, yupSchema: (args: typeof yup) => Schema<any, any>, errorMessage?: string): asserts value is T;

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@tinacms/schema-tools",
+  "version": "0.0.0-202222115457",
+  "main": "dist/index.js",
+  "typings": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "license": "Apache-2.0",
+  "buildConfig": {
+    "entryPoints": [
+      {
+        "name": "src/index.ts",
+        "target": "node"
+      }
+    ]
+  },
+  "devDependencies": {
+    "@tinacms/scripts": "0.50.7",
+    "@types/yup": "^0.29.10",
+    "jest": "^27.0.6",
+    "react": "16.14.0",
+    "typescript": "^4.3.5"
+  },
+  "peerDependencies": {
+    "react": ">=16.14.0",
+    "yup": "^0.32.0"
+  },
+  "scripts": {
+    "build": "echo \"Run `yarn build` from the root of the repository instead\"",
+    "test": "jest --passWithNoTests",
+    "types": "yarn tsc",
+    "test-watch": "jest  --passWithNoTests --watch",
+    "generate:schema": "yarn node scripts/generateSchema.js"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org"
+  },
+  "repository": {
+    "url": "https://github.com/tinacms/tinacms.git",
+    "directory": "packages/@tinacms/cli"
+  }
+}