tinacms 0.66.7 → 0.66.10

package/dist/hooks/formify/util.d.ts

@@ -10,50 +10,139 @@ 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 G from 'graphql';
-export declare const isNodeField: (type: G.GraphQLNamedType) => boolean;
-export declare const isCollectionField: (type: G.GraphQLNamedType) => boolean;
-export declare const isConnectionField: (type: G.GraphQLNamedType) => boolean;
+import { Form, Field, TinaCMS } from '@tinacms/toolkit';
+import type { DocumentBlueprint, FieldBlueprint, FormifiedDocumentNode, OnChangeEvent, FormNode, State, ChangeSet, BlueprintPath } from './types';
+import { formifyCallback, onSubmitArgs } from '../use-graphql-forms';
+interface RecursiveFormifiedDocumentNode<T extends object> extends Array<RecursiveFormifiedDocumentNode<T> | T> {
+}
 /**
- * Selects the appropriate field from a GraphQLObject based on the selection's name
+ * Gets the value from an object for a given blueprint for _all_ possible values.
+ * eg. If the blueprint is `getCollection.documents.edges.[].node` and the value is:
+ * ```
+ * {
+ *   getCollection: {
+ *      documents: {
+ *        edges: [{
+ *          node: valueA
+ *        },
+ *        {
+ *          node: valueB
+ *        }]
+ *      }
+ *   }
+ * }
+ * ```
+ * The response would be an array containing `valueA` and `valueB`
+ *
  */
-export declare const getObjectField: (object: G.GraphQLObjectType<any, any>, selectionNode: G.FieldNode) => G.GraphQLField<any, any, {
-    [key: string]: any;
-}>;
+export declare const getValueForBlueprint: <T extends object>(state: object, path: string) => T | RecursiveFormifiedDocumentNode<T>;
 /**
- * Selects the appropriate type from a union based on the selection's typeCondition
+ * Returns the name of the field. In the example query, `title` and `t` would both be blueprint fields
  *
  * ```graphql
- * post {
- *    # would return PostDocument
- *   ...on PostDocument { ... }
+ * {
+ *   getPostDocument(relativePath: $relativePath) {
+ *     data {
+ *       title,
+ *       t: title # here `t` is an alias for title
+ *     }
+ *   }
  * }
  * ```
  */
-export declare const getSelectedUnionType: (unionType: G.GraphQLUnionType, selectionNode: G.InlineFragmentNode) => G.GraphQLObjectType<any, any>;
+export declare const getFieldNameOrAlias: (fieldBlueprint: FieldBlueprint) => string;
+export declare const buildForm: (doc: FormifiedDocumentNode, cms: TinaCMS, formify: formifyCallback, showInSidebar?: boolean, onSubmit?: (args: onSubmitArgs) => void) => Form;
+export declare const formNodeId: (formNode: FormNode) => string;
+export declare const formNodePath: (formNode: FormNode) => string;
+export declare const formNodeNotIn: (formNode: FormNode, formNodes: FormNode[]) => boolean;
+export declare const sequential: <A, B>(items: A[], callback: (args: A, idx: number) => Promise<B>) => Promise<B[]>;
+export declare const getFormNodesForField: (fieldBlueprint: FieldBlueprint, formNode: FormNode, event: OnChangeEvent, state: State) => {
+    pathToChange: string;
+    formNodes: FormNode[];
+    eventLocation: any[];
+    existing: any;
+};
+export declare const getBlueprintAliasPath: (blueprint: DocumentBlueprint) => string;
+export declare const getFieldAliasForBlueprint: (path: BlueprintPath[]) => string;
 /**
  *
- * Throws an error if the provided type is no a GraphQLUnionType
- */
-export declare function ensureNodeField(field: G.GraphQLNamedType): void;
-/**
+ * Determines the appropriate fields which should recieve an update from a form change
+ *
+ * In cases where there's polymorphic blocks, it's possible that an update would affect
+ * multiple locations that it shouldn't.
+ *
+ * An OnChange event name can look like: `blocks.2.title`, but if there are 2 block elements
+ * with a field of the same name, an event name it wouldn't be enough information for us.
+ *
+ * To get around this, the event sends the current `typename` along with it, and we use that
+ * to determine where in our blueprint the value should be updated.
  *
- * Throws an error if the provided type is no a GraphQLUnionType
  */
-export declare function ensureUnionType(type: unknown): asserts type is G.GraphQLUnionType;
+export declare const getBlueprintFieldsForEvent: (blueprint: DocumentBlueprint, event: OnChangeEvent) => FieldBlueprint[];
+export declare const filterFieldBlueprintsByParentTypename: (fbp: FieldBlueprint, typename: any) => boolean;
 /**
  *
- * Throws an error if the provided type is no a GraphQLUnionType
+ * Returns the human-readable path to a blueprint or blueprint field.
+ * Optionally, appends a disambiguator to the string where necessary.
+ *
+ * eg. if a blocks field is polymporphic, specifying `true` for the disambiguator
+ *
+ * ```
+ * getPageDocument.data.blocks[].PageBlocksCta.title
+ * ```
  */
-export declare function ensureObjectType(type: unknown): asserts type is G.GraphQLObjectType;
+export declare const getBlueprintNamePath: (blueprint: Pick<DocumentBlueprint, 'path'>, disambiguator?: boolean) => string;
+export declare const stripIndices: (string: any) => any[];
+export declare const replaceRealNum: (string: any) => any;
+export declare const getMatchName: ({ field, prefix, blueprint }: {
+    field: any;
+    prefix: any;
+    blueprint: any;
+}) => {
+    matchName: string;
+    fieldName: any;
+};
+export declare const getFormNodesFromEvent: (state: State, event: OnChangeEvent) => FormNode[];
+export declare const printState: (state: State) => string;
+export declare const printEvent: (event: OnChangeEvent) => {
+    type: "forms:fields:onChange" | "forms:reset";
+    value: unknown;
+    previousValue: unknown;
+    mutationType: import("./types").ChangeMutation | import("./types").ReferenceChangeMutation | import("./types").InsertMutation | import("./types").MoveMutation | import("./types").RemoveMutation | import("./types").ResetMutation | import("./types").GlobalMutation;
+    formId: string;
+    field: {
+        data: {
+            tinaField: {
+                name: string;
+                type: "string" | "object" | "reference";
+                list?: boolean;
+                parentTypename: string;
+            };
+        };
+        name: string;
+    };
+};
+export declare const getFormNodeBlueprint: (formNode: FormNode, state: State) => DocumentBlueprint;
+export declare const getMoveMapping: (existing: any, from: any, to: any) => {
+    [key: number]: number;
+};
+export declare const matchLocation: (eventLocation: number[], formNode: FormNode) => boolean;
+export declare const bumpLocation: (location: number[]) => number[];
+export declare const maybeLowerLocation: (location: number[], at: number) => number[];
+export declare const matchesAt: (location: number[], at: number) => boolean;
+export declare const swapLocation: (location: number[], mapping: {
+    [key: number]: number;
+}) => number[];
 /**
  *
- * Throws an error if the provided type is no a GraphQLUnionType
+ * Gets the sub-fields for an object field, if it's a polymorphic
+ * object then we also need to get the __typename, though
+ * we should probably supply that regardless. The current downside
+ * of this is that it needs to come from the server because we
+ * have no way of knowing what it would be from the client-side
  */
-export declare function ensureOperationDefinition(type: G.DefinitionNode): asserts type is G.OperationDefinitionNode;
-export declare function getNameAndAlias(fieldNode: G.FieldNode, list?: boolean): {
-    name: string;
-    alias: string;
-    list: boolean;
+export declare const getSubFields: (changeSet: ChangeSet) => {
+    fields: Field[];
+    __typename: string;
 };
-export declare const metaFields: G.SelectionNode[];
+export {};

package/dist/hooks/use-graphql-forms.d.ts

@@ -10,8 +10,20 @@ 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 { Form } from '@tinacms/toolkit';
+import { Form, AnyField } from '@tinacms/toolkit';
 import type { FormOptions, TinaCMS } from '@tinacms/toolkit';
+export declare function useGraphqlFormsUnstable<T extends object>({ variables, onSubmit, query, formify, eventList, }: {
+    query: string;
+    variables: object;
+    onSubmit?: (args: onSubmitArgs) => void;
+    formify?: formifyCallback;
+    /**
+     * This is a test utility which allows us to keep track of all the events
+     * received by this hook. See `experimental-examples/unit-test-example/pages/index.js
+     * for usage.
+     */
+    eventList?: [];
+}): [T, Boolean];
 export declare function useGraphqlForms<T extends object>({ variables, onSubmit, formify, query, }: {
     query: string;
     variables: object;
@@ -27,7 +39,16 @@ export declare const transformDocumentIntoMutationRequestPayload: (document: {
     includeCollection?: boolean;
     includeTemplate?: boolean;
 }) => any;
+export declare const generateFormCreatorsUnstable: (cms: TinaCMS, showInSidebar?: boolean) => {
+    createForm: (formConfig: any) => Form<any, AnyField>;
+    createGlobalForm: GlobalFormCreator;
+};
 declare type FormCreator = (formConfig: FormOptions<any>) => Form;
+declare type GlobalFormCreator = (formConfig: FormOptions<any>, options?: GlobalFormOptions) => Form;
+interface GlobalFormOptions {
+    icon?: any;
+    layout: 'fullscreen' | 'popup';
+}
 export interface FormifyArgs {
     formConfig: FormOptions<any>;
     createForm: FormCreator;

package/dist/index.d.ts

@@ -14,7 +14,7 @@ export * from './client';
 export * from './auth';
 export * from './utils';
 export * from './tina-cms';
-export { useGraphqlForms } from './hooks/use-graphql-forms';
+export { useGraphqlForms, useGraphqlFormsUnstable, } from './hooks/use-graphql-forms';
 export { useDocumentCreatorPlugin } from './hooks/use-content-creator';
 export * from '@tinacms/toolkit';
 export { TinaAdmin } from './admin';
@@ -23,9 +23,8 @@ export { TinaAdminApi } from './admin/api';
 import { TinaCMSProvider2, TinaCMSProviderDefaultProps } from './tina-cms';
 export type { TinaCMSProviderDefaultProps };
 export default TinaCMSProvider2;
-import type { TinaCloudSchema as TinaCloudSchemaBase, TinaCloudCollection as TinaCloudCollectionBase, TinaCloudTemplateBase as TinaTemplate, TinaFieldBase } from './types';
+import type { TinaCloudSchema as TinaCloudSchemaBase, TinaCloudCollection as TinaCloudCollectionBase, TinaCloudTemplateBase as TinaTemplate, TinaFieldBase } from '@tinacms/schema-tools';
 export declare type TinaCloudSchema = TinaCloudSchemaBase<false>;
-export declare type TinaSchema = TinaCloudSchema;
 export declare type TinaCloudCollection = TinaCloudCollectionBase<false>;
 export declare type TinaCollection = TinaCloudCollectionBase<false>;
 export declare type TinaField = TinaFieldBase;