tinacms 1.5.17 → 1.5.19

package/dist/internalClient/index.d.ts

@@ -107,7 +107,7 @@ pollInterval?: number,
  *
  * Default 30 seconds.
  */
-pollTimeout?: number): ((() => void) | Promise<T>)[];
+pollTimeout?: number): (Promise<T> | (() => void))[];
 export declare class Client {
     onLogin?: OnLoginFunc;
     onLogout?: () => Promise<void>;
@@ -133,7 +133,7 @@ export declare class Client {
     get isCustomContentApi(): boolean;
     setBranch(branchName: string): void;
     getBranch(): string;
-    addPendingContent: (props: any) => Promise<unknown>;
+    addPendingContent: (props: any) => Promise<any>;
     getSchema: () => Promise<GraphQLSchema>;
     /**
      *
@@ -220,7 +220,19 @@ export declare class Client {
     }>;
     listBranches(args?: {
         includeIndexStatus?: boolean;
-    }): Promise<{
+    }): Promise<[{
+        name?: string;
+        protected?: boolean;
+        githubPullRequestUrl?: string;
+    }, ...{
+        name?: string;
+        protected?: boolean;
+        githubPullRequestUrl?: string;
+    }[]] | {
+        indexStatus: {
+            status?: "unknown" | "complete" | "failed" | "inprogress";
+            timestamp?: number;
+        };
         name?: string;
         protected?: boolean;
         githubPullRequestUrl?: string;

package/dist/tina-cms.d.ts

@@ -1,6 +1,3 @@
-/**
-
-*/
 /// <reference types="react" />
 import { useDocumentCreatorPlugin } from './hooks/use-content-creator';
 import { TinaCMSProviderDefaultProps } from './types/cms';

package/dist/toolkit/alerts/alerts.d.ts

@@ -0,0 +1,34 @@
+import React from 'react';
+import { EventBus, Callback, CMSEvent } from '../core';
+export interface EventsToAlerts {
+    [key: string]: ToAlert | AlertArgs;
+}
+export declare type ToAlert = (event: CMSEvent) => AlertArgs;
+export interface AlertArgs {
+    level: AlertLevel;
+    message: string;
+    timeout?: number;
+}
+export declare class Alerts {
+    private events;
+    private map;
+    private alerts;
+    private mapEventToAlert;
+    constructor(events: EventBus, map?: EventsToAlerts);
+    setMap(eventsToAlerts: EventsToAlerts): void;
+    add(level: AlertLevel, message: string | React.FunctionComponent, timeout?: number): () => void;
+    dismiss(alert: Alert): void;
+    subscribe(cb: Callback): () => void;
+    get all(): Alert[];
+    info(message: string | React.FunctionComponent, timeout?: number): () => void;
+    success(message: string | React.FunctionComponent, timeout?: number): () => void;
+    warn(message: string | React.FunctionComponent, timeout?: number): () => void;
+    error(message: string | React.FunctionComponent, timeout?: number): () => void;
+}
+export declare type AlertLevel = 'info' | 'success' | 'warn' | 'error';
+export interface Alert {
+    id: string;
+    level: AlertLevel;
+    message: string | React.FunctionComponent;
+    timeout: number;
+}

package/dist/toolkit/alerts/index.d.ts

@@ -0,0 +1 @@
+export * from './alerts';

package/dist/toolkit/browser-storage/browser-storage-client.d.ts

@@ -0,0 +1,12 @@
+export declare class BrowserStorageClient {
+    data: any;
+    timeout: number | null;
+    namespace: string;
+    storage: Storage;
+    constructor(storage: Storage, namespace?: string | null);
+    save(id: string, content: any): void;
+    load(id: string): any;
+    clear(id: string): void;
+    private debouncePersist;
+    private persist;
+}

package/dist/toolkit/browser-storage/get-flattened-form-values.d.ts

@@ -0,0 +1,2 @@
+import { Form } from '../forms';
+export declare function getFlattenedFormValues(form: Form): any;

package/dist/toolkit/browser-storage/index.d.ts

@@ -0,0 +1,2 @@
+export * from './browser-storage-client';
+export * from './use-form-browser-cache';

package/dist/toolkit/browser-storage/use-form-browser-cache.d.ts

@@ -0,0 +1,2 @@
+import { Form } from '../forms';
+export declare function useFormBrowserCache(form: Form<any>, editing: boolean): void;

package/dist/toolkit/components/active-field-indicator.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="react" />
+export declare const ActiveFieldIndicator: () => JSX.Element;

package/dist/toolkit/components/media/breadcrumb.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="react" />
+interface BreadcrumbProps {
+    directory?: string;
+    setDirectory: (_directory: string) => void;
+}
+export declare function Breadcrumb({ directory, setDirectory }: BreadcrumbProps): JSX.Element;
+export {};

package/dist/toolkit/components/media/copy-field.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="react" />
+interface CopyFieldProps {
+    label?: string;
+    description?: string;
+    value: any;
+}
+export declare const CopyField: ({ label, description, value }: CopyFieldProps) => JSX.Element;
+export {};

package/dist/toolkit/components/media/index.d.ts

@@ -0,0 +1,6 @@
+export * from './media-manager';
+export { ListMediaItem, GridMediaItem } from './media-item';
+export { Breadcrumb } from './breadcrumb';
+export { CursorPaginator } from './pagination';
+export type { MediaPaginatorProps } from './pagination';
+export { DEFAULT_MEDIA_UPLOAD_TYPES } from './utils';

package/dist/toolkit/components/media/media-item.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="react" />
+import { Media } from '../../core';
+interface MediaItemProps {
+    item: Media & {
+        new?: boolean;
+    };
+    onClick(_item: Media | false): void;
+    active: boolean;
+}
+export declare function ListMediaItem({ item, onClick, active }: MediaItemProps): JSX.Element;
+export declare function GridMediaItem({ item, active, onClick }: MediaItemProps): JSX.Element;
+export {};

package/dist/toolkit/components/media/media-manager.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="react" />
+import { Media } from '../../core';
+export interface MediaRequest {
+    directory?: string;
+    onSelect?(_media: Media): void;
+    close?(): void;
+    allowDelete?: boolean;
+}
+export declare function MediaManager(): JSX.Element;
+export declare function MediaPicker({ allowDelete, onSelect, close, ...props }: MediaRequest): JSX.Element;

package/dist/toolkit/components/media/modal.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="react" />
+interface DeleteModalProps {
+    close(): void;
+    deleteFunc(): void;
+    filename: string;
+}
+interface NewFolderModalProps {
+    onSubmit(filename: string): void;
+    close(): void;
+}
+export declare const DeleteModal: ({ close, deleteFunc, filename, }: DeleteModalProps) => JSX.Element;
+export declare const NewFolderModal: ({ onSubmit, close }: NewFolderModalProps) => JSX.Element;
+export {};

package/dist/toolkit/components/media/pagination.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="react" />
+export interface MediaPaginatorProps {
+    navigateNext: () => void;
+    navigatePrev: () => void;
+    hasNext: boolean;
+    hasPrev: boolean;
+    variant?: 'primary' | 'secondary' | 'white' | 'ghost';
+}
+export declare function CursorPaginator({ navigateNext, navigatePrev, hasNext, hasPrev, variant, }: MediaPaginatorProps): JSX.Element;

package/dist/toolkit/components/media/utils.d.ts

@@ -0,0 +1,4 @@
+export declare const DEFAULT_MEDIA_UPLOAD_TYPES: string;
+export declare const dropzoneAcceptFromString: (str: string) => any;
+export declare const isImage: (filename: string) => boolean;
+export declare const absoluteImgURL: (str: string) => string;

package/dist/toolkit/components/mutation-signal.d.ts

@@ -0,0 +1,12 @@
+import * as React from 'react';
+export declare const MutationSignalContext: React.Context<number>;
+/**
+ *
+ */
+export declare const MutationSignalProvider: ({ children }: {
+    children: any;
+}) => JSX.Element;
+/**
+ * Returns a value that changes when elements within the parent MutationSignalProvider change
+ */
+export declare const useMutationSignal: () => number;

package/dist/toolkit/components/tina-cms-provider.d.ts

@@ -0,0 +1,8 @@
+import * as React from 'react';
+import { TinaCMS } from '../tina-cms';
+export interface TinaCMSProviderProps {
+    cms: TinaCMS;
+    children?: React.ReactNode;
+}
+export declare const INVALID_CMS_ERROR = "The `cms` prop must be an instance of `TinaCMS`.";
+export declare const TinaCMSProvider: React.FC<TinaCMSProviderProps>;

package/dist/toolkit/components/tina-provider.d.ts

@@ -0,0 +1,14 @@
+import * as React from 'react';
+import { TinaCMSProviderProps } from './tina-cms-provider';
+import { TinaUIProps } from './tina-ui';
+export interface TinaProviderProps extends TinaCMSProviderProps, TinaUIProps {
+}
+export declare const TinaProvider: React.FC<TinaProviderProps>;
+/**
+ * @deprecated This has been renamed to `TinaProvider`.
+ */
+export declare const Tina: React.FC<TinaProviderProps>;
+/**
+ * @deprecated This has been renamed to `TinaProviderProps`.
+ */
+export declare type TinaProps = TinaProviderProps;

package/dist/toolkit/components/tina-ui.d.ts

@@ -0,0 +1,13 @@
+/**
+
+
+
+*/
+import * as React from 'react';
+import { SidebarPosition } from '../react-sidebar';
+export interface TinaUIProps {
+    position?: SidebarPosition;
+    styled?: boolean;
+    children?: React.ReactNode;
+}
+export declare const TinaUI: React.FC<TinaUIProps>;

package/dist/toolkit/core/cms.d.ts

@@ -0,0 +1,156 @@
+/**
+ * This package contains the [[CMS]] class which is the core
+ * piece of any content management system.
+ *
+ * @packageDocumentation
+ */
+import { Plugin, PluginTypeManager } from './plugins';
+import { EventBus } from './event';
+import { MediaManager, MediaStore } from './media';
+import { Flags } from './flags';
+/**
+ * A [[CMS]] is the core object of any content management system.
+ *
+ * The responsibility of the [[CMS]] keeps track of two broad types of objects:
+ *
+ * - [[Plugin|Plugins]] which extend or change the behaviour of the content management system..
+ * - [[api|APIs]] which allow the CMS to integrate with third party services.
+ * - [[EventBus|events]] which provide a way to communicate information about events happening
+ *   between decoupled parts of the CMS.
+ *
+ * The name [[CMS]] is a bit misleading. This object knows nothing of the user
+ * interface or the data storage layer. The purpose of a [[CMS]] instance is to
+ * provide a common connection point for the various aspects of a content
+ * management system. The [[CMS]] object effectively a vehicle for dependency injection.
+ *
+ * #### Creating a CMS
+ *
+ * ```ts
+ * import { CMS } from "@tinacms/core"
+ *
+ * const cms = new CMS()
+ * ```
+ *
+ * #### Extending the CMS
+ *
+ * The [[CMS]] class provides low-level interfaces for interacting with APIs and Plugins.
+ * Creating a subclass is great way to facilitate these interactions:
+ *
+ * ```ts
+ * import { CMS } from "@tinacms/core"
+ *
+ * class MyCMS extends CMS {
+ *   get colors() {
+ *     return this.plugins.findOrCreateMap("color")
+ *   }
+ * }
+ *
+ * const cms = new MyCMS()
+ *
+ * cms.colors.all()
+ * ```
+ */
+export interface CMSConfig {
+    enabled?: boolean;
+    plugins?: Array<Plugin>;
+    apis?: {
+        [key: string]: any;
+    };
+    media?: MediaStore;
+    /**
+     * Might potentially make more sense to consolidate both media.store and mediaOptions.pageSize
+     * under the 'media' config namespace, but that's a breaking change.
+     */
+    mediaOptions?: {
+        pageSize?: number;
+    };
+}
+export declare class CMS {
+    static ENABLED: {
+        type: string;
+    };
+    static DISABLED: {
+        type: string;
+    };
+    private _enabled;
+    /**
+     * An object for managing CMSs plugins.
+     *
+     * [[Plugin|Plugins]] are used to extend or modify the CMSs feature set.
+     *
+     */
+    plugins: PluginTypeManager;
+    /**
+     * The set of APIs registered with the CMS.
+     *
+     * API objects are the preferred way to interact with external APIs over a network.
+     *
+     * The preferred way to register new APIs is through the [[registerApi]] method.
+     *
+     * #### Example: Fetching Data Through an API
+     *
+     * ```ts
+     * import { CMS } from "@tinacms/core"
+     * import { CoolApi } from "cool-api"
+     *
+     * const cms = new CMS()
+     *
+     * cms.registerApi("coolApi", new CoolApi())
+     *
+     * cms.api.coolApi.fetchCoolThings().then(coolThings => {
+     *   console.log(coolThings)
+     * })
+     * ```
+     *
+     */
+    api: {
+        [key: string]: any;
+    };
+    private unsubscribeHooks;
+    events: EventBus;
+    media: MediaManager;
+    flags: Flags;
+    /**
+     * @hidden
+     */
+    constructor(config?: CMSConfig);
+    /**
+     * Registers a new external API with the CMS.
+     *
+     * #### Example
+     *
+     * ```ts
+     * import { CoolApi } from "cool-api"
+     *
+     * cms.registerApi("coolApi", new CoolApi())
+     * ```
+     *
+     * @param name The name used to lookup the external API.
+     * @param api An object for interacting with an external API.
+     *
+     * ### Additional Resources
+     *
+     * * https://github.com/tinacms/rfcs/blob/master/0010-api-events.md
+     */
+    registerApi(name: string, api: any): void;
+    /**
+     * When `true` the CMS is enabled and content can be edited.
+     */
+    get enabled(): boolean;
+    /**
+     * When `true` the CMS is disabled and content cannot be edited.
+     */
+    get disabled(): boolean;
+    /**
+     * Enable the CMS so content can be edited.
+     */
+    enable: () => void;
+    /**
+     * Disable the CMS so content can no longer be edited.
+     */
+    disable: () => void;
+    /**
+     * Toggles the enabled/disabled state of the CMS .
+     */
+    toggle: () => void;
+}

package/dist/toolkit/core/event.d.ts

@@ -0,0 +1,17 @@
+export declare type Callback<E extends CMSEvent = CMSEvent> = (event: E) => void;
+export interface CMSEvent {
+    type: string;
+    [key: string]: any;
+}
+export declare class EventBus {
+    private listeners;
+    subscribe<E extends CMSEvent = CMSEvent>(event: E['type'] | E['type'][], callback: Callback<E>): () => void;
+    dispatch<E extends CMSEvent = CMSEvent>(event: E): void;
+}
+export declare class Listener<E extends CMSEvent = CMSEvent> {
+    private eventPattern;
+    private callback;
+    constructor(eventPattern: E['type'], callback: Callback<E>);
+    handleEvent(event: E): boolean;
+    watchesEvent(currentEvent: E): boolean;
+}

package/dist/toolkit/core/flags.d.ts

@@ -0,0 +1,13 @@
+import { EventBus } from './event';
+export interface SetFlagEvent {
+    type: 'flag:set';
+    key: string;
+    value: boolean;
+}
+export declare class Flags {
+    private events;
+    private _flags;
+    constructor(events: EventBus);
+    get(key: any): boolean;
+    set(key: any, value: any): void;
+}

package/dist/toolkit/core/index.d.ts

@@ -0,0 +1,7 @@
+export * from './cms';
+export * from './event';
+export * from './subscribable';
+export * from './plugins';
+export * from './media';
+export * from './media-store.default';
+export * from './flags';

package/dist/toolkit/core/media-store.default.d.ts

@@ -0,0 +1,45 @@
+import { Media, MediaStore, MediaUploadOptions, MediaList, MediaListOptions } from './media';
+import { CMS } from './cms';
+export declare class DummyMediaStore implements MediaStore {
+    accept: string;
+    persist(files: MediaUploadOptions[]): Promise<Media[]>;
+    list(): Promise<MediaList>;
+    delete(): Promise<void>;
+}
+interface StaticMediaItem {
+    id: string;
+    filename: string;
+    src: string;
+    directory: string;
+    thumbnails: {
+        '75x75': string;
+        '400x400': string;
+        '1000x1000': string;
+    };
+    type: 'file' | 'dir';
+    children?: StaticMedia;
+}
+export interface StaticMedia {
+    [offset: string]: StaticMediaItem[];
+}
+export declare class TinaMediaStore implements MediaStore {
+    fetchFunction: (input: RequestInfo, init?: RequestInit) => Promise<Response>;
+    private api;
+    private cms;
+    private isLocal;
+    private url;
+    private staticMedia;
+    isStatic?: boolean;
+    constructor(cms: CMS, staticMedia?: StaticMedia);
+    setup(): void;
+    isAuthenticated(): Promise<any>;
+    accept: string;
+    private persist_cloud;
+    private persist_local;
+    persist(media: MediaUploadOptions[]): Promise<Media[]>;
+    private genThumbnail;
+    list(options?: MediaListOptions): Promise<MediaList>;
+    parse: (img: any) => any;
+    delete(media: Media): Promise<void>;
+}
+export {};

package/dist/toolkit/core/media.d.ts

@@ -0,0 +1,138 @@
+import { EventBus } from './event';
+/**
+ * Represents an individual file in the MediaStore
+ */
+export interface Media {
+    type: 'file' | 'dir';
+    /**
+     * A unique identifier for this file.
+     */
+    id: string;
+    /**
+     * The name of the file.
+     */
+    filename: string;
+    /**
+     * The directory where the file is stored.
+     */
+    directory: string;
+    /**
+     * A url that provides an image of the media file
+     */
+    src?: string;
+    /**
+     * A url that provides a smaller image of the media file
+     */
+    thumbnails?: {
+        [name: string]: string;
+    };
+}
+export interface MediaUploadOptions {
+    /**
+     * The directory where the file should be stored.
+     */
+    directory: string;
+    /**
+     * The File to be uploaded.
+     */
+    file: File;
+}
+/**
+ * Represents some external service for storing and
+ * managing media.
+ */
+export interface MediaStore {
+    /**
+     * The [input accept string](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input/file#accept)
+     * that describes what kind of files the Media Store will accept.
+     */
+    accept: string;
+    /**
+     * Uploads a set of files to the Media Store and
+     * returns a Promise containing the Media objects
+     * for those files.
+     */
+    persist(files: MediaUploadOptions[]): Promise<Media[]>;
+    /**
+     * Delete a media object from the store.
+     */
+    delete(media: Media): Promise<void>;
+    /**
+     * Lists all media in a specific directory.
+     */
+    list(options?: MediaListOptions): Promise<MediaList>;
+    /**
+     * Indicates that uploads and deletions are not supported
+     *
+     * @default false
+     */
+    isStatic?: boolean;
+}
+export declare type MediaListOffset = string | number;
+/**
+ * The options available when listing media.
+ */
+export interface MediaListOptions {
+    directory?: string;
+    limit?: number;
+    offset?: MediaListOffset;
+    thumbnailSizes?: {
+        w: number;
+        h: number;
+    }[];
+}
+/**
+ * The response returned from listing media.
+ */
+export interface MediaList {
+    items: Media[];
+    nextOffset?: MediaListOffset;
+}
+/**
+ * The central object for all things media.
+ *
+ * Meant to be placed directly on the `cms`
+ *
+ * ```ts
+ * cms.media = new MediaManager({
+ *   accept: '*',
+ *   async persist(files) {
+ *     // do something
+ *   }
+ * })
+ * ```
+ */
+export declare class MediaManager implements MediaStore {
+    store: MediaStore;
+    private events;
+    private _pageSize;
+    constructor(store: MediaStore, events: EventBus);
+    get isConfigured(): boolean;
+    get pageSize(): number;
+    set pageSize(pageSize: number);
+    open(options?: SelectMediaOptions): void;
+    get accept(): string;
+    persist(files: MediaUploadOptions[]): Promise<Media[]>;
+    delete(media: Media): Promise<void>;
+    list(options: MediaListOptions): Promise<MediaList>;
+}
+export interface SelectMediaOptions {
+    allowDelete?: boolean;
+    directory?: string;
+    onSelect?(media: Media): void;
+}
+interface MediaListErrorConfig {
+    title: string;
+    message: string;
+    docsLink: string;
+}
+export declare class MediaListError extends Error {
+    ERR_TYPE: string;
+    title: string;
+    docsLink: string;
+    constructor(config: MediaListErrorConfig);
+}
+export declare const E_UNAUTHORIZED: MediaListError;
+export declare const E_BAD_ROUTE: MediaListError;
+export declare const E_DEFAULT: MediaListError;
+export {};