@khanacademy/wonder-blocks-data 11.0.16 → 13.0.0

package/dist/util/hydration-cache-api.js.flow

@@ -1,29 +0,0 @@
-/**
- * Flowtype definitions for data
- * Generated by Flowgen from a Typescript Definition
- * Flowgen v1.21.0
- * @flow
- */
-import type { ValidCacheData, CachedResponse, ResponseCache } from "./types";
-
-/**
- * Initialize the hydration cache.
- * @param {ResponseCache} source The cache content to use for initializing the
- * cache.
- * @throws {Error} If the cache is already initialized.
- */
-declare export var initializeHydrationCache: (source: ResponseCache) => void;
-/**
- * Purge cached hydration responses that match the given predicate.
- * @param {(id: string) => boolean} [predicate] The predicate to match against
- * the cached hydration responses. If no predicate is provided, all cached
- * hydration responses will be purged.
- */
-declare export var purgeHydrationCache: (
-  predicate?:
-    | ((
-        key: string,
-        cacheEntry?: $ReadOnly<CachedResponse<ValidCacheData>> | null | void
-      ) => boolean)
-    | void
-) => void;

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

@@ -1,18 +0,0 @@
-/**
- * Flowtype definitions for data
- * Generated by Flowgen from a Typescript Definition
- * Flowgen v1.21.0
- * @flow
- */
-import type { GqlContext } from "./gql-types";
-
-/**
- * Construct a complete GqlContext from current defaults and a partial context.
- *
- * Values in the partial context that are `undefined` will be ignored.
- * Values in the partial context that are `null` will be deleted.
- */
-declare export var mergeGqlContext: <TContext: GqlContext>(
-  defaultContext: TContext,
-  overrides: $Rest<TContext, {}>
-) => TContext;

package/dist/util/purge-caches.js.flow

@@ -1,14 +0,0 @@
-/**
- * Flowtype definitions for data
- * Generated by Flowgen from a Typescript Definition
- * Flowgen v1.21.0
- * @flow
- */
-/**
- * Purge all caches managed by Wonder Blocks Data.
- *
- * This is a convenience method that purges the shared cache and the hydration
- * cache. It is useful for testing purposes to avoid having to reason about
- * which caches may have been used during a given test run.
- */
-declare export var purgeCaches: () => void;

package/dist/util/request-api.js.flow

@@ -1,33 +0,0 @@
-/**
- * Flowtype definitions for data
- * Generated by Flowgen from a Typescript Definition
- * Flowgen v1.21.0
- * @flow
- */
-import type { ResponseCache } from "./types";
-
-/**
- * Fetches all tracked data requests.
- *
- * This is for use with the `TrackData` component during server-side rendering.
- * @throws {Error} If executed outside of server-side rendering.
- * @returns {Promise<void>} A promise that resolves when all tracked requests
- * have been fetched.
- */
-declare export var fetchTrackedRequests: () => Promise<ResponseCache>;
-/**
- * Indicate if there are tracked requests waiting to be fetched.
- *
- * This is used in conjunction with `TrackData`.
- * @throws {Error} If executed outside of server-side rendering.
- * @returns {boolean} `true` if there are unfetched tracked requests;
- * otherwise, `false`.
- */
-declare export var hasTrackedRequestsToBeFetched: () => boolean;
-/**
- * Abort all in-flight requests.
- *
- * This aborts all requests currently inflight via our default request
- * fulfillment.
- */
-declare export var abortInflightRequests: () => void;

package/dist/util/request-fulfillment.js.flow

@@ -1,48 +0,0 @@
-/**
- * Flowtype definitions for data
- * Generated by Flowgen from a Typescript Definition
- * Flowgen v1.21.0
- * @flow
- */
-import type { Result, ValidCacheData } from "./types";
-declare type RequestCache = {
-  [id: string]: Promise<Result<any>>,
-};
-declare type FulfillOptions<TData: ValidCacheData> = {|
-  handler: () => Promise<TData>,
-  hydrate?: boolean,
-|};
-/**
- * This fulfills a request, making sure that in-flight requests are shared.
- */
-declare export class RequestFulfillment {
-  static Default: RequestFulfillment;
-  _requests: RequestCache;
-
-  /**
-   * Get a promise of a request for a given handler and options.
-   *
-   * This will return an inflight request if one exists, otherwise it will
-   * make a new request. Inflight requests are deleted once they resolve.
-   */
-  fulfill: <TData: ValidCacheData>(
-    id: string,
-    options: FulfillOptions<TData>
-  ) => Promise<Result<TData>>;
-
-  /**
-   * Abort an inflight request.
-   *
-   * NOTE: Currently, this does not perform an actual abort. It merely
-   * removes the request from being tracked.
-   */
-  abort: (id: string) => void;
-
-  /**
-   * Abort all inflight requests.
-   *
-   * NOTE: Currently, this does not perform actual aborts. It merely
-   * removes the requests from our tracking.
-   */
-  abortAll: () => void;
-}

package/dist/util/request-tracking.js.flow

@@ -1,81 +0,0 @@
-/**
- * Flowtype definitions for data
- * Generated by Flowgen from a Typescript Definition
- * Flowgen v1.21.0
- * @flow
- */
-import * as React from "react";
-import { SsrCache } from "./ssr-cache";
-import { RequestFulfillment } from "./request-fulfillment";
-import type { ResponseCache, ValidCacheData } from "./types";
-declare type TrackerFn = <TData: ValidCacheData>(
-  id: string,
-  handler: () => Promise<TData>,
-  hydrate: boolean
-) => void;
-declare type RequestCache = {
-  [id: string]: {|
-    hydrate: boolean,
-    handler: () => Promise<any>,
-  |},
-};
-/**
- * Used to inject our tracking function into the render framework.
- *
- * INTERNAL USE ONLY
- */
-declare var TrackerContext: React.Context<TrackerFn | null | void>;
-declare export { TrackerContext };
-
-/**
- * Implements request tracking and fulfillment.
- *
- * INTERNAL USE ONLY
- */
-declare export class RequestTracker {
-  static Default: RequestTracker;
-
-  /**
-   * These are the caches for tracked requests, their handlers, and responses.
-   */
-  _trackedRequests: RequestCache;
-  _responseCache: SsrCache;
-  _requestFulfillment: RequestFulfillment;
-  constructor(responseCache?: SsrCache | null): this;
-
-  /**
-   * Track a request.
-   *
-   * This method caches a request and its handler for use during server-side
-   * rendering to allow us to fulfill requests before producing a final render.
-   */
-  trackDataRequest: <TData: ValidCacheData>(
-    id: string,
-    handler: () => Promise<TData>,
-    hydrate: boolean
-  ) => void;
-
-  /**
-   * Reset our tracking info.
-   */
-  reset: () => void;
-
-  /**
-   * Indicates if we have requests waiting to be fulfilled.
-   */
-  hasUnfulfilledRequests: boolean;
-
-  /**
-   * Initiate fulfillment of all tracked requests.
-   *
-   * This loops over the requests that were tracked using TrackData, and asks
-   * the respective handlers to fulfill those requests in the order they were
-   * tracked.
-   *
-   * Calling this method marks tracked requests as fulfilled; requests are
-   * removed from the list of tracked requests by calling this method.
-   * @returns {Promise<ResponseCache>} The promise of the data that was
-   * cached as a result of fulfilling the tracked requests.
-   */
-  fulfillTrackedRequests: () => Promise<ResponseCache>;
-}

package/dist/util/result-from-cache-response.js.flow

@@ -1,14 +0,0 @@
-/**
- * Flowtype definitions for data
- * Generated by Flowgen from a Typescript Definition
- * Flowgen v1.21.0
- * @flow
- */
-import type { ValidCacheData, CachedResponse, Result } from "./types";
-
-/**
- * Turns a cache entry into a stateful result.
- */
-declare export var resultFromCachedResponse: <TData: ValidCacheData>(
-  cacheEntry?: CachedResponse<TData> | null | void
-) => Result<TData> | null | void;

package/dist/util/scoped-in-memory-cache.js.flow

@@ -1,56 +0,0 @@
-/**
- * Flowtype definitions for data
- * Generated by Flowgen from a Typescript Definition
- * Flowgen v1.21.0
- * @flow
- */
-import type { ScopedCache, RawScopedCache, ValidCacheData } from "./types";
-
-/**
- * Describe an in-memory cache.
- */
-declare export class ScopedInMemoryCache implements ScopedCache {
-  _cache: RawScopedCache;
-  constructor(initialCache?: RawScopedCache): this;
-
-  /**
-   * Indicate if this cache is being used or not.
-   *
-   * When the cache has entries, returns `true`; otherwise, returns `false`.
-   */
-  inUse: boolean;
-
-  /**
-   * Set a value in the cache.
-   */
-  set(scope: string, id: string, value: ValidCacheData): void;
-
-  /**
-   * Retrieve a value from the cache.
-   */
-  get(scope: string, id: string): ValidCacheData | null | void;
-
-  /**
-   * Purge an item from the cache.
-   */
-  purge(scope: string, id: string): void;
-
-  /**
-   * Purge a scope of items that match the given predicate.
-   *
-   * If the predicate is omitted, then all items in the scope are purged.
-   */
-  purgeScope(
-    scope: string,
-    predicate?: (id: string, value: ValidCacheData) => boolean
-  ): void;
-
-  /**
-   * Purge all items from the cache that match the given predicate.
-   *
-   * If the predicate is omitted, then all items in the cache are purged.
-   */
-  purgeAll(
-    predicate?: (scope: string, id: string, value: ValidCacheData) => boolean
-  ): void;
-}

package/dist/util/serializable-in-memory-cache.js.flow

@@ -1,25 +0,0 @@
-/**
- * Flowtype definitions for data
- * Generated by Flowgen from a Typescript Definition
- * Flowgen v1.21.0
- * @flow
- */
-import { ScopedInMemoryCache } from "./scoped-in-memory-cache";
-import type { ValidCacheData, RawScopedCache } from "./types";
-
-/**
- * Describe a serializable in-memory cache.
- */
-declare export class SerializableInMemoryCache extends ScopedInMemoryCache {
-  constructor(initialCache?: RawScopedCache): this;
-
-  /**
-   * Set a value in the cache.
-   */
-  set(scope: string, id: string, value: ValidCacheData): void;
-
-  /**
-   * Clone the cache.
-   */
-  clone(): RawScopedCache;
-}

package/dist/util/ssr-cache.js.flow

@@ -1,86 +0,0 @@
-/**
- * Flowtype definitions for data
- * Generated by Flowgen from a Typescript Definition
- * Flowgen v1.21.0
- * @flow
- */
-import { SerializableInMemoryCache } from "./serializable-in-memory-cache";
-import type { ValidCacheData, CachedResponse, ResponseCache } from "./types";
-
-/**
- * Implements the response cache.
- *
- * INTERNAL USE ONLY
- */
-declare export class SsrCache {
-  static Default: SsrCache;
-  _hydrationCache: SerializableInMemoryCache;
-  _ssrOnlyCache: SerializableInMemoryCache;
-  constructor(
-    hydrationCache?: SerializableInMemoryCache | null,
-    ssrOnlyCache?: SerializableInMemoryCache | null
-  ): this;
-  _setCachedResponse<TData: ValidCacheData>(
-    id: string,
-    entry: CachedResponse<TData>,
-    hydrate: boolean
-  ): CachedResponse<TData>;
-
-  /**
-   * Initialize the cache from a given cache state.
-   *
-   * This can only be called if the cache is not already in use.
-   */
-  initialize: (source: ResponseCache) => void;
-
-  /**
-   * Cache data for a specific response.
-   *
-   * This is a noop when client-side.
-   */
-  cacheData: <TData: ValidCacheData>(
-    id: string,
-    data: TData,
-    hydrate: boolean
-  ) => CachedResponse<TData>;
-
-  /**
-   * Cache an error for a specific response.
-   *
-   * This is a noop when client-side.
-   */
-  cacheError: <TData: ValidCacheData>(
-    id: string,
-    error: Error | string,
-    hydrate: boolean
-  ) => CachedResponse<TData>;
-
-  /**
-   * Retrieve data from our cache.
-   */
-  getEntry: <TData: ValidCacheData>(
-    id: string
-  ) => $ReadOnly<CachedResponse<TData>> | null | void;
-
-  /**
-   * Remove from cache, any entries matching the given handler and predicate.
-   *
-   * This will, if present therein, remove matching values from the framework
-   * in-memory cache.
-   *
-   * It returns a count of all records removed.
-   */
-  purgeData: (
-    predicate?: (
-      key: string,
-      cachedEntry: $ReadOnly<CachedResponse<ValidCacheData>>
-    ) => boolean
-  ) => void;
-
-  /**
-   * Deep clone the hydration cache.
-   *
-   * By design, this only clones the data that is to be used for hydration.
-   */
-  cloneHydratableData: () => ResponseCache;
-}

package/dist/util/status.js.flow

@@ -1,17 +0,0 @@
-/**
- * Flowtype definitions for data
- * Generated by Flowgen from a Typescript Definition
- * Flowgen v1.21.0
- * @flow
- */
-import type { Result, ValidCacheData } from "./types";
-
-/**
- * Create Result<TData> instances with specific statuses.
- */
-declare export var Status: $ReadOnly<{|
-  loading: <TData: ValidCacheData>() => Result<TData>,
-  aborted: <TData_1: ValidCacheData>() => Result<TData_1>,
-  success: <TData_2: ValidCacheData>(data: TData_2) => Result<TData_2>,
-  error: <TData_3: ValidCacheData>(error: Error) => Result<TData_3>,
-|}>;

package/dist/util/to-gql-operation.js.flow

@@ -1,41 +0,0 @@
-/**
- * Flowtype definitions for data
- * Generated by Flowgen from a Typescript Definition
- * Flowgen v1.21.0
- * @flow
- */
-import type { GqlOperation } from "./gql-types";
-import type { DocumentNode } from "./graphql-types";
-
-/**
- * Convert a GraphQL DocumentNode to a base Wonder Blocks Data GqlOperation.
- *
- * If you want to include the query/mutation body, extend the result of this
- * method and use the `graphql/language/printer` like:
- *
- * ```js
- * import {print} from "graphql/language/printer";
- *
- * const gqlOpWithBody = {
- *     ...toGqlOperation(documentNode),
- *     query: print(documentNode),
- * };
- * ```
- *
- * If you want to enforce inclusion of __typename properties, then you can use
- * `apollo-utilities` first to modify the document:
- *
- * ```js
- * import {print} from "graphql/language/printer";
- * import {addTypenameToDocument} from "apollo-utilities";
- *
- * const documentWithTypenames = addTypenameToDocument(documentNode);
- * const gqlOpWithBody = {
- *     ...toGqlOperation(documentWithTypenames),
- *     query: print(documentWithTypenames),
- * };
- * ```
- */
-declare export var toGqlOperation: <TData, TVariables: { [key: any]: any }>(
-  documentNode: DocumentNode
-) => GqlOperation<TData, TVariables>;

package/dist/util/types.js.flow

@@ -1,142 +0,0 @@
-/**
- * Flowtype definitions for data
- * Generated by Flowgen from a Typescript Definition
- * Flowgen v1.21.0
- * @flow
- */
-import type { Metadata } from "@khanacademy/wonder-stuff-core";
-
-/**
- * Defines the various fetch policies that can be applied to requests.
- */
-declare export var FetchPolicy: {|
-  /**
-   * If the data is in the cache, return that; otherwise, fetch from the
-   * server.
-   */
-  +CacheBeforeNetwork: "CacheBeforeNetwork",
-
-  /**
-   * If the data is in the cache, return that; always fetch from the server
-   * regardless of cache.
-   */
-  +CacheAndNetwork: "CacheAndNetwork",
-
-  /**
-   * If the data is in the cache, return that; otherwise, do nothing.
-   */
-  +CacheOnly: "CacheOnly",
-
-  /**
-   * Ignore any existing cached result; always fetch from the server.
-   */
-  +NetworkOnly: "NetworkOnly",
-|};
-/**
- * Define what can be cached.
- *
- * We disallow functions and undefined as undefined represents a cache miss
- * and functions are not allowed.
- */
-export type ValidCacheData =
-  | string
-  | boolean
-  | number
-  | { [key: any]: any }
-  | Array<ValidCacheData | null | void>;
-/**
- * The normalized result of a request.
- */
-export type Result<TData: ValidCacheData> =
-  | {|
-      status: "loading",
-    |}
-  | {|
-      status: "success",
-      data: TData,
-    |}
-  | {|
-      status: "error",
-      error: Error,
-    |}
-  | {|
-      status: "aborted",
-    |};
-/**
- * A cache entry for a fulfilled request response.
- */
-export type CachedResponse<TData: ValidCacheData> =
-  | {|
-      +error: string,
-      +data?: void,
-    |}
-  | {|
-      +data: TData,
-      +error?: void,
-    |};
-/**
- * A cache of fulfilled request responses.
- */
-export type ResponseCache = {
-  [key: string]: CachedResponse<any>,
-};
-/**
- * A cache with scoped sections.
- */
-export type RawScopedCache = {
-  /**
-   * The cache is scoped to allow easier clearing of different types of usage.
-   */
-  [scope: string]: {
-    /**
-     * Each value in the cache is then identified within a given scope.
-     */
-    [id: string]: ValidCacheData,
-  },
-};
-/**
- * Options to pass to error construction.
- */
-export type ErrorOptions = {|
-  /**
-   * Metadata to attach to the error.
-   */
-  metadata?: Metadata | null | void,
-
-  /**
-   * The error that caused the error being constructed.
-   */
-  cause?: Error | null | void,
-|};
-export interface ScopedCache {
-  set(scope: string, id: string, value: ValidCacheData): void;
-
-  /**
-   * Retrieve a value from the cache.
-   */
-  get(scope: string, id: string): ValidCacheData | null | void;
-
-  /**
-   * Purge an item from the cache.
-   */
-  purge(scope: string, id: string): void;
-
-  /**
-   * Purge a scope of items that match the given predicate.
-   *
-   * If the predicate is omitted, then all items in the scope are purged.
-   */
-  purgeScope(
-    scope: string,
-    predicate?: (id: string, value: ValidCacheData) => boolean
-  ): void;
-
-  /**
-   * Purge all items from the cache that match the given predicate.
-   *
-   * If the predicate is omitted, then all items in the cache are purged.
-   */
-  purgeAll(
-    predicate?: (scope: string, id: string, value: ValidCacheData) => boolean
-  ): void;
-}

package/src/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>,
-    ...
-};