@tinacms/schema-tools 0.0.0-00d7b85-20251222014449

package/dist/util/hasDuplicates.d.ts

@@ -0,0 +1,10 @@
+/**
+
+*/
+export declare function hasDuplicates<T = any>(array?: T[]): boolean;
+/**
+ *
+ * @param array
+ * @returns False if the array is undefined or has no duplicates.
+ */
+export declare function findDuplicates<T = any>(array?: T[] | undefined): undefined | string;

package/dist/util/index.d.ts

@@ -0,0 +1,9 @@
+/**
+
+*/
+export * from './validate';
+export * from './lastItem';
+export * from './namer';
+export * from './sequential';
+export * from './hasDuplicates';
+export * from './parseURL';

package/dist/util/lastItem.d.ts

@@ -0,0 +1,4 @@
+/**
+
+*/
+export declare const lastItem: (arr: (number | string)[]) => string | number;

package/dist/util/namer.d.ts

@@ -0,0 +1,19 @@
+/**
+
+*/
+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/normalizePath.d.ts

@@ -0,0 +1,9 @@
+export declare const normalizePath: (filepath: string) => string;
+/**
+ * Returns the given path such that:
+ * - The path separator is converted from '\' to '/' if necessary.
+ * - Duplicate '/' are removed
+ * - Leading and trailing '/' are cleared
+ * @param filepath Filepath to convert to its canonical form
+ */
+export declare const canonicalPath: (filepath: string) => string;

package/dist/util/parseURL.d.ts

@@ -0,0 +1,10 @@
+/**
+
+*/
+export declare const TINA_HOST = "content.tinajs.io";
+export declare const parseURL: (url: string) => {
+    branch: string | null;
+    isLocalClient: boolean;
+    clientId: string | null;
+    host: string | null;
+};

package/dist/util/parseZodErrors.d.ts

@@ -0,0 +1,7 @@
+/**
+
+*/
+import type { ZodError } from 'zod';
+export declare const parseZodError: ({ zodError }: {
+    zodError: ZodError;
+}) => string[];

package/dist/util/sequential.d.ts

@@ -0,0 +1,14 @@
+/**
+
+*/
+/**
+ * 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[] | undefined, callback: (args: A, idx: number) => Promise<B>) => Promise<B[]>;

package/dist/util/validate.d.ts

@@ -0,0 +1,6 @@
+/**
+
+*/
+import * as yup from 'yup';
+import type { AnySchema } from 'yup';
+export declare function assertShape<T>(value: unknown, yupSchema: (args: typeof yup) => AnySchema, errorMessage?: string): asserts value is T;

package/dist/validate/fields.d.ts

@@ -0,0 +1,3 @@
+import { z } from 'zod';
+import type { TinaField as TinaFieldType } from '../types/index';
+export declare const TinaFieldZod: z.ZodType<TinaFieldType>;

package/dist/validate/index.d.ts

@@ -0,0 +1,8 @@
+import type { Schema } from '../types/index';
+export { validateTinaCloudSchemaConfig } from './tinaCloudSchemaConfig';
+export declare class TinaSchemaValidationError extends Error {
+    constructor(message: string);
+}
+export declare const validateSchema: ({ schema }: {
+    schema: Schema;
+}) => void;

package/dist/validate/properties.d.ts

@@ -0,0 +1,5 @@
+/**
+
+*/
+import { z } from 'zod';
+export declare const name: z.ZodEffects<z.ZodString, string, string>;

package/dist/validate/schema.d.ts

@@ -0,0 +1,552 @@
+import { z } from 'zod';
+export declare const CollectionBaseSchema: z.ZodObject<{
+    label: z.ZodOptional<z.ZodString>;
+    name: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
+    path: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
+    format: z.ZodOptional<z.ZodEnum<["mdx", "md", "markdown", "json", "yaml", "yml", "toml"]>>;
+    isAuthCollection: z.ZodOptional<z.ZodBoolean>;
+    isDetached: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    name?: string;
+    label?: string;
+    path?: string;
+    format?: "mdx" | "md" | "markdown" | "json" | "yaml" | "yml" | "toml";
+    isDetached?: boolean;
+    isAuthCollection?: boolean;
+}, {
+    name?: string;
+    label?: string;
+    path?: string;
+    format?: "mdx" | "md" | "markdown" | "json" | "yaml" | "yml" | "toml";
+    isDetached?: boolean;
+    isAuthCollection?: boolean;
+}>;
+export declare const TinaCloudSchemaZod: z.ZodEffects<z.ZodObject<{
+    collections: z.ZodArray<z.ZodEffects<z.ZodObject<{
+        label: z.ZodOptional<z.ZodString>;
+        name: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
+        path: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
+        format: z.ZodOptional<z.ZodEnum<["mdx", "md", "markdown", "json", "yaml", "yml", "toml"]>>;
+        isAuthCollection: z.ZodOptional<z.ZodBoolean>;
+        isDetached: z.ZodOptional<z.ZodBoolean>;
+    } & {
+        fields: z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodOptional<z.ZodArray<z.ZodType<import("..").TinaField, z.ZodTypeDef, import("..").TinaField>, "many">>, import("..").TinaField[], import("..").TinaField[]>, import("..").TinaField[], import("..").TinaField[]>, import("..").TinaField[], import("..").TinaField[]>, import("..").TinaField[], import("..").TinaField[]>;
+        templates: z.ZodEffects<z.ZodOptional<z.ZodArray<z.ZodEffects<z.ZodObject<{
+            label: z.ZodString;
+            name: z.ZodEffects<z.ZodString, string, string>;
+            fields: z.ZodArray<z.ZodType<import("..").TinaField, z.ZodTypeDef, import("..").TinaField>, "many">;
+        }, "strip", z.ZodTypeAny, {
+            name?: string;
+            fields?: import("..").TinaField[];
+            label?: string;
+        }, {
+            name?: string;
+            fields?: import("..").TinaField[];
+            label?: string;
+        }>, {
+            name?: string;
+            fields?: import("..").TinaField[];
+            label?: string;
+        }, {
+            name?: string;
+            fields?: import("..").TinaField[];
+            label?: string;
+        }>, "many">>, {
+            name?: string;
+            fields?: import("..").TinaField[];
+            label?: string;
+        }[], {
+            name?: string;
+            fields?: import("..").TinaField[];
+            label?: string;
+        }[]>;
+    }, "strip", z.ZodTypeAny, {
+        name?: string;
+        templates?: {
+            name?: string;
+            fields?: import("..").TinaField[];
+            label?: string;
+        }[];
+        fields?: import("..").TinaField[];
+        label?: string;
+        path?: string;
+        format?: "mdx" | "md" | "markdown" | "json" | "yaml" | "yml" | "toml";
+        isDetached?: boolean;
+        isAuthCollection?: boolean;
+    }, {
+        name?: string;
+        templates?: {
+            name?: string;
+            fields?: import("..").TinaField[];
+            label?: string;
+        }[];
+        fields?: import("..").TinaField[];
+        label?: string;
+        path?: string;
+        format?: "mdx" | "md" | "markdown" | "json" | "yaml" | "yml" | "toml";
+        isDetached?: boolean;
+        isAuthCollection?: boolean;
+    }>, {
+        name?: string;
+        templates?: {
+            name?: string;
+            fields?: import("..").TinaField[];
+            label?: string;
+        }[];
+        fields?: import("..").TinaField[];
+        label?: string;
+        path?: string;
+        format?: "mdx" | "md" | "markdown" | "json" | "yaml" | "yml" | "toml";
+        isDetached?: boolean;
+        isAuthCollection?: boolean;
+    }, {
+        name?: string;
+        templates?: {
+            name?: string;
+            fields?: import("..").TinaField[];
+            label?: string;
+        }[];
+        fields?: import("..").TinaField[];
+        label?: string;
+        path?: string;
+        format?: "mdx" | "md" | "markdown" | "json" | "yaml" | "yml" | "toml";
+        isDetached?: boolean;
+        isAuthCollection?: boolean;
+    }>, "many">;
+    config: z.ZodOptional<z.ZodObject<{
+        client: z.ZodOptional<z.ZodObject<{
+            referenceDepth: z.ZodOptional<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            referenceDepth?: number;
+        }, {
+            referenceDepth?: number;
+        }>>;
+        media: z.ZodOptional<z.ZodObject<{
+            tina: z.ZodOptional<z.ZodObject<{
+                publicFolder: z.ZodString;
+                mediaRoot: z.ZodString;
+                static: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+            }, "strict", z.ZodTypeAny, {
+                publicFolder?: string;
+                mediaRoot?: string;
+                static?: boolean;
+            }, {
+                publicFolder?: string;
+                mediaRoot?: string;
+                static?: boolean;
+            }>>;
+            loadCustomStore: z.ZodOptional<z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodUnknown>>;
+        }, "strip", z.ZodTypeAny, {
+            tina?: {
+                publicFolder?: string;
+                mediaRoot?: string;
+                static?: boolean;
+            };
+            loadCustomStore?: (...args: unknown[]) => unknown;
+        }, {
+            tina?: {
+                publicFolder?: string;
+                mediaRoot?: string;
+                static?: boolean;
+            };
+            loadCustomStore?: (...args: unknown[]) => unknown;
+        }>>;
+        search: z.ZodOptional<z.ZodObject<{
+            tina: z.ZodOptional<z.ZodObject<{
+                indexerToken: z.ZodOptional<z.ZodString>;
+                stopwordLanguages: z.ZodOptional<z.ZodArray<z.ZodString, "atleastone">>;
+                tokenSplitRegex: z.ZodOptional<z.ZodString>;
+                fuzzyEnabled: z.ZodOptional<z.ZodBoolean>;
+                fuzzyOptions: z.ZodOptional<z.ZodObject<{
+                    maxDistance: z.ZodOptional<z.ZodNumber>;
+                    minSimilarity: z.ZodOptional<z.ZodNumber>;
+                    maxResults: z.ZodOptional<z.ZodNumber>;
+                    useTranspositions: z.ZodOptional<z.ZodBoolean>;
+                    caseSensitive: z.ZodOptional<z.ZodBoolean>;
+                }, "strict", z.ZodTypeAny, {
+                    maxDistance?: number;
+                    minSimilarity?: number;
+                    maxResults?: number;
+                    useTranspositions?: boolean;
+                    caseSensitive?: boolean;
+                }, {
+                    maxDistance?: number;
+                    minSimilarity?: number;
+                    maxResults?: number;
+                    useTranspositions?: boolean;
+                    caseSensitive?: boolean;
+                }>>;
+            }, "strict", z.ZodTypeAny, {
+                indexerToken?: string;
+                stopwordLanguages?: [string, ...string[]];
+                tokenSplitRegex?: string;
+                fuzzyEnabled?: boolean;
+                fuzzyOptions?: {
+                    maxDistance?: number;
+                    minSimilarity?: number;
+                    maxResults?: number;
+                    useTranspositions?: boolean;
+                    caseSensitive?: boolean;
+                };
+            }, {
+                indexerToken?: string;
+                stopwordLanguages?: [string, ...string[]];
+                tokenSplitRegex?: string;
+                fuzzyEnabled?: boolean;
+                fuzzyOptions?: {
+                    maxDistance?: number;
+                    minSimilarity?: number;
+                    maxResults?: number;
+                    useTranspositions?: boolean;
+                    caseSensitive?: boolean;
+                };
+            }>>;
+            searchClient: z.ZodOptional<z.ZodAny>;
+            indexBatchSize: z.ZodOptional<z.ZodNumber>;
+            maxSearchIndexFieldLength: z.ZodOptional<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            maxSearchIndexFieldLength?: number;
+            tina?: {
+                indexerToken?: string;
+                stopwordLanguages?: [string, ...string[]];
+                tokenSplitRegex?: string;
+                fuzzyEnabled?: boolean;
+                fuzzyOptions?: {
+                    maxDistance?: number;
+                    minSimilarity?: number;
+                    maxResults?: number;
+                    useTranspositions?: boolean;
+                    caseSensitive?: boolean;
+                };
+            };
+            searchClient?: any;
+            indexBatchSize?: number;
+        }, {
+            maxSearchIndexFieldLength?: number;
+            tina?: {
+                indexerToken?: string;
+                stopwordLanguages?: [string, ...string[]];
+                tokenSplitRegex?: string;
+                fuzzyEnabled?: boolean;
+                fuzzyOptions?: {
+                    maxDistance?: number;
+                    minSimilarity?: number;
+                    maxResults?: number;
+                    useTranspositions?: boolean;
+                    caseSensitive?: boolean;
+                };
+            };
+            searchClient?: any;
+            indexBatchSize?: number;
+        }>>;
+        ui: z.ZodOptional<z.ZodObject<{
+            previewUrl: z.ZodOptional<z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodUnknown>>;
+            optOutOfUpdateCheck: z.ZodOptional<z.ZodBoolean>;
+            regexValidation: z.ZodOptional<z.ZodObject<{
+                folderNameRegex: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+            }, "strip", z.ZodTypeAny, {
+                folderNameRegex?: string;
+            }, {
+                folderNameRegex?: string;
+            }>>;
+        }, "strip", z.ZodTypeAny, {
+            previewUrl?: (...args: unknown[]) => unknown;
+            optOutOfUpdateCheck?: boolean;
+            regexValidation?: {
+                folderNameRegex?: string;
+            };
+        }, {
+            previewUrl?: (...args: unknown[]) => unknown;
+            optOutOfUpdateCheck?: boolean;
+            regexValidation?: {
+                folderNameRegex?: string;
+            };
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        search?: {
+            maxSearchIndexFieldLength?: number;
+            tina?: {
+                indexerToken?: string;
+                stopwordLanguages?: [string, ...string[]];
+                tokenSplitRegex?: string;
+                fuzzyEnabled?: boolean;
+                fuzzyOptions?: {
+                    maxDistance?: number;
+                    minSimilarity?: number;
+                    maxResults?: number;
+                    useTranspositions?: boolean;
+                    caseSensitive?: boolean;
+                };
+            };
+            searchClient?: any;
+            indexBatchSize?: number;
+        };
+        ui?: {
+            previewUrl?: (...args: unknown[]) => unknown;
+            optOutOfUpdateCheck?: boolean;
+            regexValidation?: {
+                folderNameRegex?: string;
+            };
+        };
+        client?: {
+            referenceDepth?: number;
+        };
+        media?: {
+            tina?: {
+                publicFolder?: string;
+                mediaRoot?: string;
+                static?: boolean;
+            };
+            loadCustomStore?: (...args: unknown[]) => unknown;
+        };
+    }, {
+        search?: {
+            maxSearchIndexFieldLength?: number;
+            tina?: {
+                indexerToken?: string;
+                stopwordLanguages?: [string, ...string[]];
+                tokenSplitRegex?: string;
+                fuzzyEnabled?: boolean;
+                fuzzyOptions?: {
+                    maxDistance?: number;
+                    minSimilarity?: number;
+                    maxResults?: number;
+                    useTranspositions?: boolean;
+                    caseSensitive?: boolean;
+                };
+            };
+            searchClient?: any;
+            indexBatchSize?: number;
+        };
+        ui?: {
+            previewUrl?: (...args: unknown[]) => unknown;
+            optOutOfUpdateCheck?: boolean;
+            regexValidation?: {
+                folderNameRegex?: string;
+            };
+        };
+        client?: {
+            referenceDepth?: number;
+        };
+        media?: {
+            tina?: {
+                publicFolder?: string;
+                mediaRoot?: string;
+                static?: boolean;
+            };
+            loadCustomStore?: (...args: unknown[]) => unknown;
+        };
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    collections?: {
+        name?: string;
+        templates?: {
+            name?: string;
+            fields?: import("..").TinaField[];
+            label?: string;
+        }[];
+        fields?: import("..").TinaField[];
+        label?: string;
+        path?: string;
+        format?: "mdx" | "md" | "markdown" | "json" | "yaml" | "yml" | "toml";
+        isDetached?: boolean;
+        isAuthCollection?: boolean;
+    }[];
+    config?: {
+        search?: {
+            maxSearchIndexFieldLength?: number;
+            tina?: {
+                indexerToken?: string;
+                stopwordLanguages?: [string, ...string[]];
+                tokenSplitRegex?: string;
+                fuzzyEnabled?: boolean;
+                fuzzyOptions?: {
+                    maxDistance?: number;
+                    minSimilarity?: number;
+                    maxResults?: number;
+                    useTranspositions?: boolean;
+                    caseSensitive?: boolean;
+                };
+            };
+            searchClient?: any;
+            indexBatchSize?: number;
+        };
+        ui?: {
+            previewUrl?: (...args: unknown[]) => unknown;
+            optOutOfUpdateCheck?: boolean;
+            regexValidation?: {
+                folderNameRegex?: string;
+            };
+        };
+        client?: {
+            referenceDepth?: number;
+        };
+        media?: {
+            tina?: {
+                publicFolder?: string;
+                mediaRoot?: string;
+                static?: boolean;
+            };
+            loadCustomStore?: (...args: unknown[]) => unknown;
+        };
+    };
+}, {
+    collections?: {
+        name?: string;
+        templates?: {
+            name?: string;
+            fields?: import("..").TinaField[];
+            label?: string;
+        }[];
+        fields?: import("..").TinaField[];
+        label?: string;
+        path?: string;
+        format?: "mdx" | "md" | "markdown" | "json" | "yaml" | "yml" | "toml";
+        isDetached?: boolean;
+        isAuthCollection?: boolean;
+    }[];
+    config?: {
+        search?: {
+            maxSearchIndexFieldLength?: number;
+            tina?: {
+                indexerToken?: string;
+                stopwordLanguages?: [string, ...string[]];
+                tokenSplitRegex?: string;
+                fuzzyEnabled?: boolean;
+                fuzzyOptions?: {
+                    maxDistance?: number;
+                    minSimilarity?: number;
+                    maxResults?: number;
+                    useTranspositions?: boolean;
+                    caseSensitive?: boolean;
+                };
+            };
+            searchClient?: any;
+            indexBatchSize?: number;
+        };
+        ui?: {
+            previewUrl?: (...args: unknown[]) => unknown;
+            optOutOfUpdateCheck?: boolean;
+            regexValidation?: {
+                folderNameRegex?: string;
+            };
+        };
+        client?: {
+            referenceDepth?: number;
+        };
+        media?: {
+            tina?: {
+                publicFolder?: string;
+                mediaRoot?: string;
+                static?: boolean;
+            };
+            loadCustomStore?: (...args: unknown[]) => unknown;
+        };
+    };
+}>, {
+    collections?: {
+        name?: string;
+        templates?: {
+            name?: string;
+            fields?: import("..").TinaField[];
+            label?: string;
+        }[];
+        fields?: import("..").TinaField[];
+        label?: string;
+        path?: string;
+        format?: "mdx" | "md" | "markdown" | "json" | "yaml" | "yml" | "toml";
+        isDetached?: boolean;
+        isAuthCollection?: boolean;
+    }[];
+    config?: {
+        search?: {
+            maxSearchIndexFieldLength?: number;
+            tina?: {
+                indexerToken?: string;
+                stopwordLanguages?: [string, ...string[]];
+                tokenSplitRegex?: string;
+                fuzzyEnabled?: boolean;
+                fuzzyOptions?: {
+                    maxDistance?: number;
+                    minSimilarity?: number;
+                    maxResults?: number;
+                    useTranspositions?: boolean;
+                    caseSensitive?: boolean;
+                };
+            };
+            searchClient?: any;
+            indexBatchSize?: number;
+        };
+        ui?: {
+            previewUrl?: (...args: unknown[]) => unknown;
+            optOutOfUpdateCheck?: boolean;
+            regexValidation?: {
+                folderNameRegex?: string;
+            };
+        };
+        client?: {
+            referenceDepth?: number;
+        };
+        media?: {
+            tina?: {
+                publicFolder?: string;
+                mediaRoot?: string;
+                static?: boolean;
+            };
+            loadCustomStore?: (...args: unknown[]) => unknown;
+        };
+    };
+}, {
+    collections?: {
+        name?: string;
+        templates?: {
+            name?: string;
+            fields?: import("..").TinaField[];
+            label?: string;
+        }[];
+        fields?: import("..").TinaField[];
+        label?: string;
+        path?: string;
+        format?: "mdx" | "md" | "markdown" | "json" | "yaml" | "yml" | "toml";
+        isDetached?: boolean;
+        isAuthCollection?: boolean;
+    }[];
+    config?: {
+        search?: {
+            maxSearchIndexFieldLength?: number;
+            tina?: {
+                indexerToken?: string;
+                stopwordLanguages?: [string, ...string[]];
+                tokenSplitRegex?: string;
+                fuzzyEnabled?: boolean;
+                fuzzyOptions?: {
+                    maxDistance?: number;
+                    minSimilarity?: number;
+                    maxResults?: number;
+                    useTranspositions?: boolean;
+                    caseSensitive?: boolean;
+                };
+            };
+            searchClient?: any;
+            indexBatchSize?: number;
+        };
+        ui?: {
+            previewUrl?: (...args: unknown[]) => unknown;
+            optOutOfUpdateCheck?: boolean;
+            regexValidation?: {
+                folderNameRegex?: string;
+            };
+        };
+        client?: {
+            referenceDepth?: number;
+        };
+        media?: {
+            tina?: {
+                publicFolder?: string;
+                mediaRoot?: string;
+                static?: boolean;
+            };
+            loadCustomStore?: (...args: unknown[]) => unknown;
+        };
+    };
+}>;