@tinacms/schema-tools 0.1.9 → 0.2.1

package/dist/index.d.ts

@@ -11,6 +11,6 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 export * from './schema';
-export * from './types';
+export * from './types/index';
 export * from './validate';
 export * from './util/namer';

package/dist/index.es.js

@@ -263,12 +263,23 @@ class TinaSchema {
             assertShape(value, (yup2) => yup2.array(yup2.object({ _template: yup2.string().required() })));
             return value.map((item) => {
               const { _template, ...rest } = item;
-              return { [_template]: rest };
+              const template = field.templates.find((template2) => {
+                if (typeof template2 === "string") {
+                  return false;
+                }
+                return template2.name === _template;
+              });
+              if (typeof template === "string") {
+                throw new Error("Global templates not supported");
+              }
+              return {
+                [_template]: this.transformCollectablePayload(rest, template)
+              };
             });
           } else {
             assertShape(value, (yup2) => yup2.object({ _template: yup2.string().required() }));
             const { _template, ...rest } = value;
-            return { [_template]: rest };
+            return { [_template]: this.transformCollectablePayload(rest, field) };
           }
         } else {
           return value;
@@ -587,7 +598,7 @@ const ReferenceField = FieldWithList.extend({
 });
 const TinaFieldZod = z.lazy(() => {
   const TemplateTemp = z.object({
-    label: z.string(),
+    label: z.string().optional(),
     name: nameProp,
     fields: z.array(TinaFieldZod),
     match: z.object({

package/dist/index.js

@@ -290,12 +290,23 @@
               assertShape(value, (yup2) => yup2.array(yup2.object({ _template: yup2.string().required() })));
               return value.map((item) => {
                 const { _template, ...rest } = item;
-                return { [_template]: rest };
+                const template = field.templates.find((template2) => {
+                  if (typeof template2 === "string") {
+                    return false;
+                  }
+                  return template2.name === _template;
+                });
+                if (typeof template === "string") {
+                  throw new Error("Global templates not supported");
+                }
+                return {
+                  [_template]: this.transformCollectablePayload(rest, template)
+                };
               });
             } else {
               assertShape(value, (yup2) => yup2.object({ _template: yup2.string().required() }));
               const { _template, ...rest } = value;
-              return { [_template]: rest };
+              return { [_template]: this.transformCollectablePayload(rest, field) };
             }
           } else {
             return value;
@@ -614,7 +625,7 @@
   });
   const TinaFieldZod = z.z.lazy(() => {
     const TemplateTemp = z.z.object({
-      label: z.z.string(),
+      label: z.z.string().optional(),
       name: nameProp,
       fields: z.z.array(TinaFieldZod),
       match: z.z.object({

package/dist/schema/TinaSchema.d.ts

@@ -10,7 +10,7 @@ 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';
+import { TinaCloudSchemaEnriched, TinaCloudSchemaBase, TinaCloudCollection, Templateable, Collectable, CollectionTemplateable } from '../types/index';
 declare type Version = {
     fullVersion: string;
     major: string;
@@ -49,8 +49,8 @@ export declare class TinaSchema {
     getGlobalTemplate: (templateName: string) => {
         label: string;
         name: string;
-        ui?: import("../types").UICollection;
-        fields: import("../types").TinaFieldInner<true>[];
+        ui?: import("../types/SchemaTypes").UICollection;
+        fields: import("../types/SchemaTypes").TinaFieldInner<true>[];
         namespace: string[];
     };
     getCollectionByFullPath: (filepath: string) => TinaCloudCollection<true>;

package/dist/schema/resolveField.d.ts

@@ -10,7 +10,7 @@ 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 { TinaFieldEnriched } from '../types/index';
 import { TinaSchema } from './TinaSchema';
 /**
  *

package/dist/schema/resolveForm.d.ts

@@ -10,7 +10,7 @@ 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';
+import type { ResolveFormArgs } from '../types/index';
 /**
  *  Given a collection, basename, template and schema. This will transform the given information into a valid frontend form config
  */

package/dist/types/SchemaTypes.d.ts

@@ -28,6 +28,9 @@ export declare type UIField<F extends UIField = any, Shape = any> = {
 export interface TinaCloudSchema<WithNamespace extends boolean, Store = any> {
     templates?: GlobalTemplate<WithNamespace>[];
     collections: TinaCloudCollection<WithNamespace>[];
+    /**
+     * @deprecated use `defineConfig` in a config.{js,ts} file instead
+     */
     config?: TinaCloudSchemaConfig<Store>;
 }
 export declare type TinaCloudSchemaBase = TinaCloudSchema<false>;
@@ -66,8 +69,23 @@ export declare type TinaIndex = {
     }[];
 };
 export interface UICollection {
+    /**
+     * Customize the way filenames are generated during content creation
+     */
     filename?: {
+        /**
+         * A callback which receives form values as an argument. The return value
+         * here will be used as the filename (the extension is not necessary)
+         *
+         * eg:
+         * ```ts
+         * slugify: (values) => values.title.toLowerCase().split(" ").join("-")
+         * ```
+         */
         slugify?: (values: Record<string, any>) => string;
+        /**
+         * When set to `true`, editors won't be able to modify the filename
+         */
         readonly?: boolean;
     };
     /**
@@ -92,7 +110,7 @@ export interface UICollection {
         collection: TinaCloudCollection<true>;
     }) => string | undefined;
 }
-declare type DefaultItem<ReturnType> = ReturnType | (() => ReturnType);
+export declare type DefaultItem<ReturnType> = ReturnType | (() => ReturnType);
 interface BaseCollection {
     label?: string;
     name: string;
@@ -149,7 +167,7 @@ export interface TinaField {
     ui?: Record<string, any>;
 }
 declare type ScalarType<WithNamespace extends boolean> = WithNamespace extends true ? ScalarTypeWithNamespace : ScalarTypeInner;
-declare type Option = string | {
+export declare type Option = string | {
     label: string;
     value: string;
 };

package/dist/types/index.d.ts

@@ -16,4 +16,3 @@ limitations under the License.
 
 */
 export * from './SchemaTypes';
-export * from './SchemaTypes2';

package/dist/types/schema2.d.ts

@@ -10,4 +10,126 @@ 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 { Option, UICollection } from './SchemaTypes';
+/**
+ * NOTE this is WIP - it's not being used but ideally
+ * we can start to leverage it for the `defineStaticConfig`
+ *
+ * The current schema type defs are way more complex to be
+ * user-facing. This schema also gets rid of stuff we didn't
+ * get around to implementing like `templates: string` (which
+ * were for global templates)
+ *
+ */
+declare type FC<T> = (props: T) => unknown;
+declare type UIField<Type> = {
+    label?: string;
+    description?: string;
+    component?: FC<any> | string | null;
+    parse?: (value: Type, name: string, field: Field) => any;
+    format?: (value: Type, name: string, field: Field) => any;
+    validate?(value: Type, allValues: any, meta: any): Type | undefined | void;
+    /**
+     * @deprecated use `defaultItem` at the collection level instead
+     */
+    defaultValue?: Type;
+};
+declare type FieldGeneric<Type> = {
+    required: true;
+    list: true;
+    ui?: UIField<Type[]>;
+} | {
+    required: true;
+    list?: false | undefined;
+    ui?: UIField<Type>;
+} | {
+    required?: false | undefined;
+    list: true;
+    ui?: UIField<Type[] | undefined>;
+} | {
+    required?: false | undefined;
+    list?: false | undefined;
+    ui?: UIField<Type | undefined>;
+};
+declare type BaseField<Type, Ui extends object = undefined> = {
+    name: string;
+    label?: string;
+    description?: string;
+    ui?: Ui extends object ? UIField<Type> & Ui : UIField<Type>;
+} & FieldGeneric<Type>;
+declare type StringFieldBase = {
+    type: 'string';
+    /** Designate this field's value as the document title  */
+    isTitle?: boolean;
+    options?: Option[];
+} & BaseField<string>;
+declare type StringField = StringFieldBase & FieldGeneric<string>;
+declare type NumberField = {
+    type: 'number';
+} & BaseField<number>;
+declare type BooleanField = {
+    type: 'boolean';
+} & BaseField<boolean>;
+declare type DateTimeField = {
+    type: 'datetime';
+} & BaseField<string>;
+declare type ImageField = {
+    type: 'image';
+} & BaseField<string>;
+declare type ReferenceField = {
+    type: 'reference';
+    collections: string[];
+} & BaseField<string>;
+declare type RichTextField = {
+    type: 'rich-text';
+    /**
+     * For markdown or MDX formats, this value will be
+     * saved to the document body
+     */
+    isBody?: boolean;
+} & BaseField<object> & WithTemplates<true>;
+declare type ObjectField = ({
+    type: 'object';
+} & BaseField<object, {
+    itemProps?(item: Record<string, any>): {
+        key?: string;
+        label?: string;
+    };
+}>) & (WithFields | WithTemplates);
+declare type Field = StringField | NumberField | BooleanField | DateTimeField | ImageField | ReferenceField | RichTextField | ObjectField;
+declare type WithFields = {
+    fields: Field[];
+    templates?: never;
+};
+declare type Template = {
+    name: string;
+    label?: string;
+    fields: Field[];
+    match?: {
+        start: string;
+        end: string;
+    };
+};
+declare type WithTemplates<Optional extends boolean = false> = Optional extends true ? {
+    templates?: Template[];
+    fields?: never;
+} : {
+    templates: Template[];
+    fields?: never;
+};
+declare type TinaCMSCollection = {
+    label?: string;
+    name: string;
+    path: string;
+    format?: 'json' | 'md' | 'markdown' | 'mdx';
+    match?: string;
+    ui?: UICollection;
+} & (WithTemplates | WithFields);
+/**
+ * @deprecated use TinaCMSSchema instead
+ */
+export declare type TinaCloudSchema = TinaCMSSchema;
+export declare type TinaCMSSchema = {
+    collections: TinaCMSCollection[];
+};
 export {};