@khanacademy/wonder-blocks-data 11.0.15 → 12.0.0

package/dist/hooks/use-cached-effect.js.flow

@@ -1,83 +0,0 @@
-/**
- * Flowtype definitions for data
- * Generated by Flowgen from a Typescript Definition
- * Flowgen v1.21.0
- * @flow
- */
-import type { Result, ValidCacheData } from "../util/types";
-import { FetchPolicy } from "../util/types";
-declare type CachedEffectOptions<TData: ValidCacheData> = {|
-  /**
-   * The policy to use when determining how to retrieve the request data from
-   * cache and network.
-   *
-   * Defaults to `FetchPolicy.CacheBeforeNetwork`.
-   */
-  fetchPolicy?: $ElementType<typeof FetchPolicy, $Keys<typeof FetchPolicy>>,
-
-  /**
-   * When `true`, the effect will not be executed; otherwise, the effect will
-   * be executed.
-   *
-   * If this is set to `true` while the effect is still pending, the pending
-   * effect will be cancelled.
-   *
-   * Default is `false`.
-   */
-  skip?: boolean,
-
-  /**
-   * When `true`, the effect will not reset the result to the loading status
-   * while executing if the requestId changes, instead, returning
-   * the existing result from before the change; otherwise, the result will
-   * be set to loading status.
-   *
-   * If the status is loading when the changes are made, it will remain as
-   * loading; old pending effects are discarded on changes and as such this
-   * value has no effect in that case.
-   */
-  retainResultOnChange?: boolean,
-
-  /**
-   * Callback that is invoked if the result for the given hook has changed.
-   *
-   * When defined, the hook will invoke this callback whenever it has reason
-   * to change the result and will not otherwise affect component rendering
-   * directly.
-   *
-   * When not defined, the hook will ensure the component re-renders to pick
-   * up the latest result.
-   */
-  onResultChanged?: (result: Result<TData>) => void,
-
-  /**
-   * Scope to use with the shared cache.
-   *
-   * When specified, the given scope will be used to isolate this hook's
-   * cached results. Otherwise, a shared default scope will be used.
-   *
-   * Changing this value after the first call is not supported.
-   */
-  scope?: string,
-|};
-/**
- * Hook to execute and cache an async operation on the client.
- *
- * This hook executes the given handler on the client if there is no
- * cached result to use.
- *
- * Results are cached so they can be shared between equivalent invocations.
- * In-flight requests are also shared, so that concurrent calls will
- * behave as one might exect. Cache updates invoked by one hook instance
- * do not trigger renders in components that use the same requestID; however,
- * that should not matter since concurrent requests will share the same
- * in-flight request, and subsequent renders will grab from the cache.
- *
- * Once the request has been tried once and a non-loading response has been
- * cached, the request will not executed made again.
- */
-declare export var useCachedEffect: <TData: ValidCacheData>(
-  requestId: string,
-  handler: () => Promise<TData>,
-  options?: CachedEffectOptions<TData>
-) => [Result<TData>, () => void];

package/dist/hooks/use-gql-router-context.js.flow

@@ -1,14 +0,0 @@
-/**
- * Flowtype definitions for data
- * Generated by Flowgen from a Typescript Definition
- * Flowgen v1.21.0
- * @flow
- */
-import type { GqlRouterConfiguration, GqlContext } from "../util/gql-types";
-
-/**
- * Construct a GqlRouterContext from the current one and partial context.
- */
-declare export var useGqlRouterContext: <TContext: GqlContext>(
-  contextOverrides?: $Rest<TContext, {}>
-) => GqlRouterConfiguration<TContext>;

package/dist/hooks/use-gql.js.flow

@@ -1,28 +0,0 @@
-/**
- * Flowtype definitions for data
- * Generated by Flowgen from a Typescript Definition
- * Flowgen v1.21.0
- * @flow
- */
-import type {
-  GqlContext,
-  GqlOperation,
-  GqlFetchOptions,
-} from "../util/gql-types";
-
-/**
- * Hook to obtain a gqlFetch function for performing GraphQL requests.
- *
- * The fetch function will resolve null if the request was aborted, otherwise
- * it will resolve the data returned by the GraphQL server.
- *
- * Context is merged with the default context provided to the GqlRouter.
- * Values in the partial context given to the returned fetch function will
- * only be included if they have a value other than undefined.
- */
-declare export var useGql: <TContext: GqlContext>(
-  context?: $Rest<TContext, {}>
-) => <TData, TVariables: { [key: any]: any }>(
-  operation: GqlOperation<TData, TVariables>,
-  options?: GqlFetchOptions<TVariables, TContext> | void
-) => Promise<TData>;

package/dist/hooks/use-hydratable-effect.js.flow

@@ -1,122 +0,0 @@
-/**
- * Flowtype definitions for data
- * Generated by Flowgen from a Typescript Definition
- * Flowgen v1.21.0
- * @flow
- */
-import type { Result, ValidCacheData } from "../util/types";
-
-/**
- * Policies to define how a hydratable effect should behave client-side.
- */
-declare export var WhenClientSide: {|
-  /**
-   * The result from executing the effect server-side will not be hydrated.
-   * The effect will always be executed client-side.
-   *
-   * This should only be used if there is something else that is responsible
-   * for properly hydrating this component (for example, the action invokes
-   * Apollo which manages its own cache to ensure things render properly).
-   */
-  +DoNotHydrate: "DoNotHydrate",
-
-  /**
-   * The result from executing the effect server-side will be hydrated.
-   * The effect will only execute client-side if there was no result to
-   * be hydrated (i.e. both error and success hydration results prevent the
-   * effect running client-side).
-   */
-  +ExecuteWhenNoResult: "ExecuteWhenNoResult",
-
-  /**
-   * The result from executing the effect server-side will be hydrated.
-   * If the hydrated result is a success result, the effect will not be
-   * executed client-side.
-   * If the hydrated result was not a success result, or there was no
-   * hydrated result, the effect will not be executed.
-   */
-  +ExecuteWhenNoSuccessResult: "ExecuteWhenNoSuccessResult",
-
-  /**
-   * The result from executing the effect server-side will be hydrated.
-   * The effect will always be executed client-side, regardless of the
-   * hydrated result status.
-   */
-  +AlwaysExecute: "AlwaysExecute",
-|};
-declare type HydratableEffectOptions<TData: ValidCacheData> = {|
-  /**
-   * How the hook should behave when rendering client-side for the first time.
-   *
-   * This controls how the hook hydrates and executes when client-side.
-   *
-   * Default is `WhenClientSide.ExecuteWhenNoSuccessResult`.
-   *
-   * Changing this value after the first call is irrelevant as it only
-   * affects the initial render behavior.
-   */
-  clientBehavior?: $ElementType<
-    typeof WhenClientSide,
-    $Keys<typeof WhenClientSide>
-  >,
-
-  /**
-   * When `true`, the effect will not be executed; otherwise, the effect will
-   * be executed.
-   *
-   * If this is set to `true` while the effect is still pending, the pending
-   * effect will be cancelled.
-   *
-   * Default is `false`.
-   */
-  skip?: boolean,
-
-  /**
-   * When `true`, the effect will not reset the result to the loading status
-   * while executing if the requestId changes, instead, returning
-   * the existing result from before the change; otherwise, the result will
-   * be set to loading status.
-   *
-   * If the status is loading when the changes are made, it will remain as
-   * loading; old pending effects are discarded on changes and as such this
-   * value has no effect in that case.
-   */
-  retainResultOnChange?: boolean,
-
-  /**
-   * Callback that is invoked if the result for the given hook has changed.
-   *
-   * When defined, the hook will invoke this callback whenever it has reason
-   * to change the result and will not otherwise affect component rendering
-   * directly.
-   *
-   * When not defined, the hook will ensure the component re-renders to pick
-   * up the latest result.
-   */
-  onResultChanged?: (result: Result<TData>) => void,
-
-  /**
-   * Scope to use with the shared cache.
-   *
-   * When specified, the given scope will be used to isolate this hook's
-   * cached results. Otherwise, a shared default scope will be used.
-   *
-   * Changing this value after the first call is not supported.
-   */
-  scope?: string,
-|};
-/**
- * Hook to execute an async operation on server and client.
- *
- * This hook executes the given handler on the server and on the client,
- * and, depending on the given options, can hydrate the server-side result.
- *
- * Results are cached on the client so they can be shared between equivalent
- * invocations. Cache changes from one hook instance do not trigger renders
- * in components that use the same requestID.
- */
-declare export var useHydratableEffect: <TData: ValidCacheData>(
-  requestId: string,
-  handler: () => Promise<TData>,
-  options?: HydratableEffectOptions<TData>
-) => Result<TData>;

package/dist/hooks/use-request-interception.js.flow

@@ -1,24 +0,0 @@
-/**
- * Flowtype definitions for data
- * Generated by Flowgen from a Typescript Definition
- * Flowgen v1.21.0
- * @flow
- */
-import type { ValidCacheData } from "../util/types";
-
-/**
- * Allow request handling to be intercepted.
- *
- * Hook to take a uniquely identified request handler and return a
- * method that will support request interception from the InterceptRequest
- * component.
- *
- * If you want request interception to be supported with `useServerEffect` or
- * any client-side effect that uses the handler, call this first to generate
- * an intercepted handler, and then invoke `useServerEffect` (or other things)
- * with that intercepted handler.
- */
-declare export var useRequestInterception: <TData: ValidCacheData>(
-  requestId: string,
-  handler: () => Promise<TData>
-) => () => Promise<TData>;

package/dist/hooks/use-server-effect.js.flow

@@ -1,49 +0,0 @@
-/**
- * Flowtype definitions for data
- * Generated by Flowgen from a Typescript Definition
- * Flowgen v1.21.0
- * @flow
- */
-import type { Result, ValidCacheData } from "../util/types";
-declare type ServerEffectOptions = {|
-  /**
-   * When `true`, the result of the effect when fulfilled using Wonder Blocks
-   * Data will be stored in the hydration cache for hydrating client-side;
-   * otherwise, the result will be stored in the server-side-only cache.
-   *
-   * This should only be set to `false` if something else will be responsible
-   * for hydration of the data on the client-side (for example, if Apollo's
-   * hydration support is used).
-   *
-   * Default is `true`.
-   */
-  hydrate?: boolean,
-
-  /**
-   * When `true`, the effect will not be tracked for fulfillment; otherwise,
-   * the effect will be tracked for fulfillment.
-   *
-   * Default is `false`.
-   */
-  skip?: boolean,
-|};
-/**
- * Hook to perform an asynchronous action during server-side rendering.
- *
- * This hook registers an asynchronous action to be performed during
- * server-side rendering. The action is performed only once, and the result
- * is cached against the given identifier so that subsequent calls return that
- * cached result allowing components to render more of the component.
- *
- * This hook requires the Wonder Blocks Data functionality for resolving
- * pending requests, as well as support for the hydration cache to be
- * embedded into a page so that the result can by hydrated (if that is a
- * requirement).
- *
- * The asynchronous action is never invoked on the client-side.
- */
-declare export var useServerEffect: <TData: ValidCacheData>(
-  requestId: string,
-  handler: () => Promise<TData>,
-  options?: ServerEffectOptions
-) => Result<TData> | null | void;

package/dist/hooks/use-shared-cache.js.flow

@@ -1,42 +0,0 @@
-/**
- * Flowtype definitions for data
- * Generated by Flowgen from a Typescript Definition
- * Flowgen v1.21.0
- * @flow
- */
-import type { ValidCacheData, ScopedCache } from "../util/types";
-
-/**
- * A function for inserting a value into the cache or clearing it.
- */
-declare type CacheValueFn<TValue: ValidCacheData> = (
-  value?: TValue | null | void
-) => void;
-/**
- * Access to the shared in-memory cache.
- *
- * This is the cache used by `useSharedCache` and related hooks and
- * components.
- */
-declare export var SharedCache: ScopedCache;
-/**
- * Hook to retrieve data from and store data in an in-memory cache.
- * @returns {[?ReadOnlyCacheValue, CacheValueFn]} Returns an array containing the current cache entry (or undefined), a
- * function to set the cache entry (passing null or undefined to this function
- * will delete the entry).
- *
- * NOTE: Unlike useState or useReducer, we don't automatically update folks
- * if the value they reference changes. We might add it later (if we need to),
- * but the likelihood here is that things won't be changing in this cache in a
- * way where we would need that. If we do (and likely only in specific
- * circumstances), we should consider adding a simple boolean useState that can
- * be toggled to cause a rerender whenever the referenced cached data changes
- * so that callers can re-render on cache changes. However, we should make
- * sure this toggling is optional - or we could use a callback argument, to
- * achieve this on an as-needed basis.
- */
-declare export var useSharedCache: <TValue: ValidCacheData>(
-  id: string,
-  scope: string,
-  initialValue?: TValue | (() => TValue | null | void) | null | void
-) => [TValue | null | void, CacheValueFn<TValue>];

package/dist/index.js.flow

@@ -1,47 +0,0 @@
-/**
- * Flowtype definitions for data
- * Generated by Flowgen from a Typescript Definition
- * Flowgen v1.21.0
- * @flow
- */
-declare export { FetchPolicy } from "./util/types";
-export type {
-  ErrorOptions,
-  ResponseCache,
-  CachedResponse,
-  Result,
-  RawScopedCache,
-  ValidCacheData,
-  ScopedCache,
-} from "./util/types";
-declare export * from "./util/hydration-cache-api";
-declare export * from "./util/request-api";
-declare export { purgeCaches } from "./util/purge-caches";
-declare export { default as TrackData } from "./components/track-data";
-declare export { default as Data } from "./components/data";
-declare export { default as InterceptRequests } from "./components/intercept-requests";
-declare export { DataError, DataErrors } from "./util/data-error";
-declare export { useServerEffect } from "./hooks/use-server-effect";
-declare export { useCachedEffect } from "./hooks/use-cached-effect";
-declare export { useSharedCache, SharedCache } from "./hooks/use-shared-cache";
-declare export {
-  useHydratableEffect,
-  WhenClientSide,
-} from "./hooks/use-hydratable-effect";
-declare export { ScopedInMemoryCache } from "./util/scoped-in-memory-cache";
-declare export { SerializableInMemoryCache } from "./util/serializable-in-memory-cache";
-declare export { Status } from "./util/status";
-declare export { getGqlRequestId } from "./util/get-gql-request-id";
-declare export { getGqlDataFromResponse } from "./util/get-gql-data-from-response";
-declare export { graphQLDocumentNodeParser } from "./util/graphql-document-node-parser";
-declare export { toGqlOperation } from "./util/to-gql-operation";
-declare export { GqlRouter } from "./components/gql-router";
-declare export { useGql } from "./hooks/use-gql";
-declare export { GqlError, GqlErrors } from "./util/gql-error";
-export type {
-  GqlContext,
-  GqlOperation,
-  GqlOperationType,
-  GqlFetchOptions,
-  GqlFetchFn,
-} from "./util/gql-types";

package/dist/util/data-error.js.flow

@@ -1,62 +0,0 @@
-/**
- * Flowtype definitions for data
- * Generated by Flowgen from a Typescript Definition
- * Flowgen v1.21.0
- * @flow
- */
-import { KindError } from "@khanacademy/wonder-stuff-core";
-import type { ErrorOptions } from "./types";
-
-/**
- * Error kinds for DataError.
- */
-declare export var DataErrors: $ReadOnly<{|
-  /**
-   * The kind of error is not known.
-   */
-  Unknown: "Unknown",
-
-  /**
-   * The error is internal to the executing code.
-   */
-  Internal: "Internal",
-
-  /**
-   * There was a problem with the provided input.
-   */
-  InvalidInput: "InvalidInput",
-
-  /**
-   * A network error occurred.
-   */
-  Network: "Network",
-
-  /**
-   * There was a problem due to the state of the system not matching the
-   * requested operation or input.
-   */
-  NotAllowed: "NotAllowed",
-
-  /**
-   * Response could not be parsed.
-   */
-  Parse: "Parse",
-
-  /**
-   * An error that occurred during SSR and was hydrated from cache
-   */
-  Hydrated: "Hydrated",
-|}>;
-/**
- * An error from the Wonder Blocks Data API.
- *
- * Errors of this type will have names of the format:
- *     `${kind}DataError`
- */
-declare export class DataError extends KindError {
-  constructor(
-    message: string,
-    kind: $ElementType<typeof DataErrors, $Keys<typeof DataErrors>>,
-    x?: ErrorOptions
-  ): this;
-}

package/dist/util/get-gql-data-from-response.js.flow

@@ -1,12 +0,0 @@
-/**
- * Flowtype definitions for data
- * Generated by Flowgen from a Typescript Definition
- * Flowgen v1.21.0
- * @flow
- */
-/**
- * Validate a GQL operation response and extract the data.
- */
-declare export var getGqlDataFromResponse: <TData>(
-  response: Response
-) => Promise<TData>;

package/dist/util/get-gql-request-id.js.flow

@@ -1,16 +0,0 @@
-/**
- * Flowtype definitions for data
- * Generated by Flowgen from a Typescript Definition
- * Flowgen v1.21.0
- * @flow
- */
-import type { GqlOperation, GqlContext } from "./gql-types";
-
-/**
- * Get an identifier for a given request.
- */
-declare export var getGqlRequestId: <TData, TVariables: { [key: any]: any }>(
-  operation: GqlOperation<TData, TVariables>,
-  variables: TVariables | null | void,
-  context: GqlContext
-) => string;

package/dist/util/gql-error.js.flow

@@ -1,41 +0,0 @@
-/**
- * Flowtype definitions for data
- * Generated by Flowgen from a Typescript Definition
- * Flowgen v1.21.0
- * @flow
- */
-import { KindError } from "@khanacademy/wonder-stuff-core";
-import type { ErrorOptions } from "./types";
-
-/**
- * Error kinds for GqlError.
- */
-declare export var GqlErrors: $ReadOnly<{|
-  /**
-   * An internal framework error.
-   */
-  Internal: "Internal",
-
-  /**
-   * Response does not have the correct structure for a GraphQL response.
-   */
-  BadResponse: "BadResponse",
-
-  /**
-   * A valid GraphQL result with errors field in the payload.
-   */
-  ErrorResult: "ErrorResult",
-|}>;
-/**
- * An error from the GQL API.
- *
- * Errors of this type will have names of the format:
- *     `${kind}GqlError`
- */
-declare export class GqlError extends KindError {
-  constructor(
-    message: string,
-    kind: $ElementType<typeof GqlErrors, $Keys<typeof GqlErrors>>,
-    x?: ErrorOptions
-  ): this;
-}

package/dist/util/gql-router-context.js.flow

@@ -1,10 +0,0 @@
-/**
- * Flowtype definitions for data
- * Generated by Flowgen from a Typescript Definition
- * Flowgen v1.21.0
- * @flow
- */
-import * as React from "react";
-import type { GqlRouterConfiguration } from "./gql-types";
-declare var GqlRouterContext: React.Context<GqlRouterConfiguration<any> | null | void>;
-declare export { GqlRouterContext };

package/dist/util/gql-types.js.flow

@@ -1,50 +0,0 @@
-/**
- * Flowtype definitions for data
- * Generated by Flowgen from a Typescript Definition
- * Flowgen v1.21.0
- * @flow
- */
-/**
- * Operation types.
- */
-export type GqlOperationType = "mutation" | "query";
-/**
- * A GraphQL operation.
- */
-export type GqlOperation<TData, TVariables: { ... } = Empty> = {
-  type: GqlOperationType,
-  id: string,
-  [key: string]: mixed,
-};
-export type GqlContext = {
-  [key: string]: string,
-};
-/**
- * Functions that make fetches of GQL operations.
- */
-export type GqlFetchFn<
-  TData,
-  TVariables: { [key: any]: any },
-  TContext: GqlContext
-> = (
-  operation: GqlOperation<TData, TVariables>,
-  variables: TVariables | null | void,
-  context: TContext
-) => Promise<Response>;
-/**
- * The configuration stored in the GqlRouterContext context.
- */
-export type GqlRouterConfiguration<TContext: GqlContext> = {|
-  fetch: GqlFetchFn<any, any, any>,
-  defaultContext: TContext,
-|};
-/**
- * Options for configuring a GQL fetch.
- */
-export type GqlFetchOptions<
-  TVariables: { [key: any]: any },
-  TContext: GqlContext
-> = {|
-  variables?: TVariables,
-  context?: $Rest<TContext, {}>,
-|};

package/dist/util/graphql-document-node-parser.js.flow

@@ -1,29 +0,0 @@
-/**
- * Flowtype definitions for data
- * Generated by Flowgen from a Typescript Definition
- * Flowgen v1.21.0
- * @flow
- */
-import type { DocumentNode, VariableDefinitionNode } from "./graphql-types";
-declare export var DocumentTypes: $ReadOnly<{|
-  query: "query",
-  mutation: "mutation",
-|}>;
-export type DocumentType = $ElementType<
-  typeof DocumentTypes,
-  $Keys<typeof DocumentTypes>
->;
-export interface IDocumentDefinition {
-  type: DocumentType;
-  name: string;
-  variables: $ReadOnlyArray<VariableDefinitionNode>;
-}
-/**
- * Parse a GraphQL document node to determine some info about it.
- *
- * This is based on:
- * https://github.com/apollographql/react-apollo/blob/3bc993b2ea91704bd6a2667f42d1940656c071ff/src/parser.ts
- */
-declare export function graphQLDocumentNodeParser(
-  document: DocumentNode
-): IDocumentDefinition;

package/dist/util/graphql-types.js.flow

@@ -1,30 +0,0 @@
-// @flow
-// NOTE(somewhatabstract):
-// These types are bare minimum to support document parsing. They're derived
-// from graphql@14.5.8, the last version that provided flow types.
-// Doing this avoids us having to take a dependency on that library just for
-// these types.
-export interface DefinitionNode {
-    +kind: string;
-}
-
-export type VariableDefinitionNode = {
-    +kind: "VariableDefinition",
-    ...
-};
-
-export interface OperationDefinitionNode extends DefinitionNode {
-    +kind: "OperationDefinition";
-    +operation: string;
-    +variableDefinitions: $ReadOnlyArray<VariableDefinitionNode>;
-    +name?: {|
-        +kind: mixed,
-        +value: string,
-    |};
-}
-
-export type DocumentNode = {
-    +kind: "Document",
-    +definitions: $ReadOnlyArray<DefinitionNode>,
-    ...
-};