@khanacademy/wonder-blocks-data 11.0.16 → 12.0.0

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # @khanacademy/wonder-blocks-data
 
+## 12.0.0
+
+### Major Changes
+
+-   674a1e5c: POJOs have been replace with TS enums
+
+### Patch Changes
+
+-   674a1e5c: We're no longer building flow types
+-   Updated dependencies [674a1e5c]
+-   Updated dependencies [674a1e5c]
+    -   @khanacademy/wonder-blocks-core@6.0.0
+
 ## 11.0.16
 
 ### Patch Changes

package/dist/es/index.js

@@ -3,12 +3,13 @@ import { KindError, clone, entries } from '@khanacademy/wonder-stuff-core';
 import * as React from 'react';
 import { useContext, useRef, useMemo, useCallback } from 'react';
 
-const FetchPolicy = {
-  CacheBeforeNetwork: "CacheBeforeNetwork",
-  CacheAndNetwork: "CacheAndNetwork",
-  CacheOnly: "CacheOnly",
-  NetworkOnly: "NetworkOnly"
-};
+let FetchPolicy = function (FetchPolicy) {
+  FetchPolicy["CacheBeforeNetwork"] = "CacheBeforeNetwork";
+  FetchPolicy["CacheAndNetwork"] = "CacheAndNetwork";
+  FetchPolicy["CacheOnly"] = "CacheOnly";
+  FetchPolicy["NetworkOnly"] = "NetworkOnly";
+  return FetchPolicy;
+}({});
 
 const DataErrors = Object.freeze({
   Unknown: "Unknown",
@@ -533,12 +534,13 @@ const useCachedEffect = (requestId, handler, options = {}) => {
   return [result, fetchRequest];
 };
 
-const WhenClientSide = {
-  DoNotHydrate: "DoNotHydrate",
-  ExecuteWhenNoResult: "ExecuteWhenNoResult",
-  ExecuteWhenNoSuccessResult: "ExecuteWhenNoSuccessResult",
-  AlwaysExecute: "AlwaysExecute"
-};
+let WhenClientSide = function (WhenClientSide) {
+  WhenClientSide["DoNotHydrate"] = "DoNotHydrate";
+  WhenClientSide["ExecuteWhenNoResult"] = "ExecuteWhenNoResult";
+  WhenClientSide["ExecuteWhenNoSuccessResult"] = "ExecuteWhenNoSuccessResult";
+  WhenClientSide["AlwaysExecute"] = "AlwaysExecute";
+  return WhenClientSide;
+}({});
 const DefaultScope = "useHydratableEffect";
 const useHydratableEffect = (requestId, handler, options = {}) => {
   const {

package/dist/hooks/use-hydratable-effect.d.ts

@@ -2,7 +2,7 @@ import type { Result, ValidCacheData } from "../util/types";
 /**
  * Policies to define how a hydratable effect should behave client-side.
  */
-export declare const WhenClientSide: {
+export declare enum WhenClientSide {
     /**
      * The result from executing the effect server-side will not be hydrated.
      * The effect will always be executed client-side.
@@ -11,14 +11,14 @@ export declare const WhenClientSide: {
      * for properly hydrating this component (for example, the action invokes
      * Apollo which manages its own cache to ensure things render properly).
      */
-    readonly DoNotHydrate: "DoNotHydrate";
+    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).
      */
-    readonly ExecuteWhenNoResult: "ExecuteWhenNoResult";
+    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
@@ -26,14 +26,14 @@ export declare const WhenClientSide: {
      * If the hydrated result was not a success result, or there was no
      * hydrated result, the effect will not be executed.
      */
-    readonly ExecuteWhenNoSuccessResult: "ExecuteWhenNoSuccessResult";
+    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.
      */
-    readonly AlwaysExecute: "AlwaysExecute";
-};
+    AlwaysExecute = "AlwaysExecute"
+}
 type HydratableEffectOptions<TData extends ValidCacheData> = {
     /**
      * How the hook should behave when rendering client-side for the first time.

package/dist/index.js

@@ -26,12 +26,13 @@ function _interopNamespace(e) {
 
 var React__namespace = /*#__PURE__*/_interopNamespace(React);
 
-const FetchPolicy = {
-  CacheBeforeNetwork: "CacheBeforeNetwork",
-  CacheAndNetwork: "CacheAndNetwork",
-  CacheOnly: "CacheOnly",
-  NetworkOnly: "NetworkOnly"
-};
+let FetchPolicy = function (FetchPolicy) {
+  FetchPolicy["CacheBeforeNetwork"] = "CacheBeforeNetwork";
+  FetchPolicy["CacheAndNetwork"] = "CacheAndNetwork";
+  FetchPolicy["CacheOnly"] = "CacheOnly";
+  FetchPolicy["NetworkOnly"] = "NetworkOnly";
+  return FetchPolicy;
+}({});
 
 const DataErrors = Object.freeze({
   Unknown: "Unknown",
@@ -556,12 +557,13 @@ const useCachedEffect = (requestId, handler, options = {}) => {
   return [result, fetchRequest];
 };
 
-const WhenClientSide = {
-  DoNotHydrate: "DoNotHydrate",
-  ExecuteWhenNoResult: "ExecuteWhenNoResult",
-  ExecuteWhenNoSuccessResult: "ExecuteWhenNoSuccessResult",
-  AlwaysExecute: "AlwaysExecute"
-};
+let WhenClientSide = function (WhenClientSide) {
+  WhenClientSide["DoNotHydrate"] = "DoNotHydrate";
+  WhenClientSide["ExecuteWhenNoResult"] = "ExecuteWhenNoResult";
+  WhenClientSide["ExecuteWhenNoSuccessResult"] = "ExecuteWhenNoSuccessResult";
+  WhenClientSide["AlwaysExecute"] = "AlwaysExecute";
+  return WhenClientSide;
+}({});
 const DefaultScope = "useHydratableEffect";
 const useHydratableEffect = (requestId, handler, options = {}) => {
   const {

package/dist/util/types.d.ts

@@ -2,26 +2,26 @@ import type { Metadata } from "@khanacademy/wonder-stuff-core";
 /**
  * Defines the various fetch policies that can be applied to requests.
  */
-export declare const FetchPolicy: {
+export declare enum FetchPolicy {
     /**
      * If the data is in the cache, return that; otherwise, fetch from the
      * server.
      */
-    readonly CacheBeforeNetwork: "CacheBeforeNetwork";
+    CacheBeforeNetwork = "CacheBeforeNetwork",
     /**
      * If the data is in the cache, return that; always fetch from the server
      * regardless of cache.
      */
-    readonly CacheAndNetwork: "CacheAndNetwork";
+    CacheAndNetwork = "CacheAndNetwork",
     /**
      * If the data is in the cache, return that; otherwise, do nothing.
      */
-    readonly CacheOnly: "CacheOnly";
+    CacheOnly = "CacheOnly",
     /**
      * Ignore any existing cached result; always fetch from the server.
      */
-    readonly NetworkOnly: "NetworkOnly";
-};
+    NetworkOnly = "NetworkOnly"
+}
 /**
  * Define what can be cached.
  *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@khanacademy/wonder-blocks-data",
-  "version": "11.0.16",
+  "version": "12.0.0",
   "design": "v1",
   "publishConfig": {
     "access": "public"
@@ -14,14 +14,14 @@
   },
   "dependencies": {
     "@babel/runtime": "^7.18.6",
-    "@khanacademy/wonder-blocks-core": "^5.4.0"
+    "@khanacademy/wonder-blocks-core": "^6.0.0"
   },
   "peerDependencies": {
     "@khanacademy/wonder-stuff-core": "^1.2.2",
     "react": "16.14.0"
   },
   "devDependencies": {
-    "wb-dev-build-settings": "^0.9.7"
+    "@khanacademy/wb-dev-build-settings": "^1.0.0"
   },
   "author": "",
   "license": "MIT"

package/src/hooks/use-hydratable-effect.ts

@@ -10,8 +10,7 @@ import type {Result, ValidCacheData} from "../util/types";
 /**
  * Policies to define how a hydratable effect should behave client-side.
  */
-// TODO(FEI-5000): Convert to TS enum after all codebases have been migrated
-export const WhenClientSide = {
+export enum WhenClientSide {
     /**
      * The result from executing the effect server-side will not be hydrated.
      * The effect will always be executed client-side.
@@ -20,7 +19,7 @@ export const WhenClientSide = {
      * for properly hydrating this component (for example, the action invokes
      * Apollo which manages its own cache to ensure things render properly).
      */
-    DoNotHydrate: "DoNotHydrate" as const,
+    DoNotHydrate = "DoNotHydrate",
 
     /**
      * The result from executing the effect server-side will be hydrated.
@@ -28,7 +27,7 @@ export const WhenClientSide = {
      * be hydrated (i.e. both error and success hydration results prevent the
      * effect running client-side).
      */
-    ExecuteWhenNoResult: "ExecuteWhenNoResult" as const,
+    ExecuteWhenNoResult = "ExecuteWhenNoResult",
 
     /**
      * The result from executing the effect server-side will be hydrated.
@@ -37,15 +36,15 @@ export const WhenClientSide = {
      * If the hydrated result was not a success result, or there was no
      * hydrated result, the effect will not be executed.
      */
-    ExecuteWhenNoSuccessResult: "ExecuteWhenNoSuccessResult" as const,
+    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" as const,
-} as const;
+    AlwaysExecute = "AlwaysExecute",
+}
 
 type HydratableEffectOptions<TData extends ValidCacheData> = {
     /**

package/src/util/types.ts

@@ -3,30 +3,29 @@ import type {Metadata} from "@khanacademy/wonder-stuff-core";
 /**
  * Defines the various fetch policies that can be applied to requests.
  */
-// TODO(FEI-5000): Convert to TS enum after all codebases have been migrated
-export const FetchPolicy = {
+export enum FetchPolicy {
     /**
      * If the data is in the cache, return that; otherwise, fetch from the
      * server.
      */
-    CacheBeforeNetwork: "CacheBeforeNetwork" as const,
+    CacheBeforeNetwork = "CacheBeforeNetwork",
 
     /**
      * If the data is in the cache, return that; always fetch from the server
      * regardless of cache.
      */
-    CacheAndNetwork: "CacheAndNetwork" as const,
+    CacheAndNetwork = "CacheAndNetwork",
 
     /**
      * If the data is in the cache, return that; otherwise, do nothing.
      */
-    CacheOnly: "CacheOnly" as const,
+    CacheOnly = "CacheOnly",
 
     /**
      * Ignore any existing cached result; always fetch from the server.
      */
-    NetworkOnly: "NetworkOnly" as const,
-} as const;
+    NetworkOnly = "NetworkOnly",
+}
 
 /**
  * Define what can be cached.