@adyen/adyen-platform-experience-web 0.1.2 → 1.0.0-beta.1

package/dist/es/utils/watchable/core/Watchable.test.js

@@ -0,0 +1,103 @@
+import { noop } from "../../common/index.js";
+import __Watchable__ from "./Watchable.js";
+import { UNWATCH_SIGNAL } from "../constants.js";
+import { d as describe, b as beforeEach, t as test, g as globalExpect, v as vi } from "../../../../vendor-vi.a3ff54b1-5e924357.mjs";
+describe("Watchable", () => {
+  beforeEach((context) => {
+    let VERSION = 1;
+    Object.defineProperties(context, {
+      version: {
+        enumerable: true,
+        get: () => VERSION,
+        set: (version) => {
+          VERSION = version;
+        }
+      },
+      watchable: { enumerable: true, value: new __Watchable__({ version: () => VERSION }) },
+      watchFn: { enumerable: true, value: vi.fn() }
+    });
+  });
+  test("should create watchable instance", (context) => {
+    const watchable = context.watchable;
+    globalExpect(watchable).toHaveProperty("idle");
+    globalExpect(watchable).toHaveProperty("idleCallbacks");
+    globalExpect(watchable).toHaveProperty("notifyWatchers");
+    globalExpect(watchable).toHaveProperty("snapshot");
+    globalExpect(watchable).toHaveProperty("watch");
+    globalExpect(watchable.idle).toBe(true);
+    globalExpect(watchable.idleCallbacks.idle).toBe(noop);
+    globalExpect(watchable.idleCallbacks.resume).toBe(noop);
+    globalExpect(watchable.snapshot).toBeTypeOf("object");
+    globalExpect(watchable.snapshot).toHaveProperty("version");
+    globalExpect(watchable.snapshot.version).toBe(context.version);
+    globalExpect(watchable.notifyWatchers).toBeTypeOf("function");
+    globalExpect(watchable.watch).toBeTypeOf("function");
+    globalExpect(watchable.notifyWatchers()).toBe(void 0);
+  });
+  test("should recompute state snapshot correctly", (context) => {
+    const watchable = context.watchable;
+    globalExpect(watchable.idle).toBe(true);
+    globalExpect(watchable.snapshot.version).toBe(context.version++);
+    globalExpect(watchable.snapshot.version).toBe(context.version);
+    const unwatch = watchable.watch(context.watchFn);
+    globalExpect(context.watchFn).toBeCalledTimes(1);
+    globalExpect(watchable.idle).toBe(false);
+    context.version++;
+    globalExpect(watchable.snapshot.version).not.toBe(context.version);
+    globalExpect(watchable.snapshot.version).toBe(context.version - 1);
+    globalExpect(watchable.notifyWatchers()).toBe(true);
+    globalExpect(context.watchFn).toBeCalledTimes(2);
+    globalExpect(watchable.snapshot.version).toBe(context.version);
+    unwatch();
+    globalExpect(watchable.idle).toBe(true);
+    context.version++;
+    globalExpect(watchable.snapshot.version).toBe(context.version);
+  });
+  test("should trigger watch and idle callbacks correctly", (context) => {
+    const watchable = context.watchable;
+    const idleCallback = watchable.idleCallbacks.idle = vi.fn();
+    const resumeCallback = watchable.idleCallbacks.resume = vi.fn();
+    globalExpect(resumeCallback).toBeCalledTimes(0);
+    globalExpect(idleCallback).toBeCalledTimes(0);
+    globalExpect(watchable.idle).toBe(true);
+    const unwatch = watchable.watch(context.watchFn);
+    globalExpect(context.watchFn).toBeCalledTimes(1);
+    globalExpect(resumeCallback).toBeCalledTimes(1);
+    globalExpect(idleCallback).toBeCalledTimes(0);
+    globalExpect(watchable.idle).toBe(false);
+    globalExpect(watchable.notifyWatchers()).toBe(false);
+    globalExpect(watchable.snapshot.version).toBe(context.version);
+    globalExpect(context.watchFn).toBeCalledTimes(1);
+    context.version++;
+    globalExpect(watchable.notifyWatchers()).toBe(true);
+    globalExpect(context.watchFn).toBeCalledTimes(2);
+    globalExpect(watchable.snapshot.version).toBe(context.version);
+    const unwatch2 = watchable.watch(context.watchFn);
+    globalExpect(context.watchFn).toBeCalledTimes(3);
+    globalExpect(resumeCallback).toBeCalledTimes(1);
+    globalExpect(idleCallback).toBeCalledTimes(0);
+    globalExpect(unwatch).toBe(unwatch2);
+    context.version++;
+    globalExpect(watchable.notifyWatchers()).toBe(true);
+    globalExpect(context.watchFn).toBeCalledTimes(4);
+    unwatch();
+    globalExpect(resumeCallback).toBeCalledTimes(1);
+    globalExpect(idleCallback).toBeCalledTimes(0);
+    globalExpect(watchable.idle).toBe(false);
+    unwatch2();
+    globalExpect(resumeCallback).toBeCalledTimes(1);
+    globalExpect(idleCallback).toBeCalledTimes(1);
+    globalExpect(watchable.idle).toBe(true);
+  });
+  test("should trigger callbacks correctly with unwatch signal", (context) => {
+    const watchable = context.watchable;
+    const anotherWatchFn = vi.fn();
+    watchable.watch(context.watchFn);
+    watchable.watch(anotherWatchFn);
+    globalExpect(watchable.notifyWatchers(UNWATCH_SIGNAL)).toBe(true);
+    globalExpect(context.watchFn).toBeCalledTimes(2);
+    globalExpect(anotherWatchFn).toBeCalledTimes(2);
+    globalExpect(context.watchFn).toHaveBeenLastCalledWith(UNWATCH_SIGNAL);
+    globalExpect(anotherWatchFn).toHaveBeenLastCalledWith(UNWATCH_SIGNAL);
+  });
+});

package/dist/es/utils/watchable/core/helpers.js

@@ -1,26 +1,33 @@
-import { isFunction as c, struct as i, noop as n } from "../../common/index.js";
-const f = (e = {}) => {
-  const o = {};
-  for (const t of Object.keys(e)) {
-    const { get: r, value: s } = Object.getOwnPropertyDescriptor(e, t);
-    o[t] = {
-      enumerable: !0,
-      get: r || (c(s) ? s.bind(e) : () => s)
+import { isFunction, struct, noop } from "../../common/index.js";
+const createLiveWatchableState = (watchableAtoms = {}) => {
+  const descriptors = {};
+  for (const key of Object.keys(watchableAtoms)) {
+    const { get, value } = Object.getOwnPropertyDescriptor(watchableAtoms, key);
+    descriptors[key] = {
+      enumerable: true,
+      get: get || (isFunction(value) ? value.bind(watchableAtoms) : () => value)
     };
   }
-  return i(o);
-}, p = () => {
-  const e = { idle: n, resume: n }, o = {};
-  for (const t of Object.keys(e))
-    o[t] = {
-      get: () => e[t],
-      set: (r) => {
-        r == null ? e[t] = n : c(r) && r !== e[t] && (e[t] = r);
+  return struct(descriptors);
+};
+const createWatchableIdleCallbacks = () => {
+  const callbacks = { idle: noop, resume: noop };
+  const descriptors = {};
+  for (const key of Object.keys(callbacks)) {
+    descriptors[key] = {
+      get: () => callbacks[key],
+      set: (callback) => {
+        if (callback == void 0) {
+          callbacks[key] = noop;
+        } else if (isFunction(callback) && callback !== callbacks[key]) {
+          callbacks[key] = callback;
+        }
       }
     };
-  return i(o);
+  }
+  return struct(descriptors);
 };
 export {
-  f as createLiveWatchableState,
-  p as createWatchableIdleCallbacks
+  createLiveWatchableState,
+  createWatchableIdleCallbacks
 };

package/dist/es/utils/watchable/core/helpers.test.js

@@ -0,0 +1,106 @@
+import { createLiveWatchableState, createWatchableIdleCallbacks } from "./helpers.js";
+import { noop } from "../../common/index.js";
+import { d as describe, t as test, g as globalExpect } from "../../../../vendor-vi.a3ff54b1-5e924357.mjs";
+describe("createLiveWatchableState", () => {
+  test("should have constant state getters for static atoms", () => {
+    let NUMBER = 30;
+    let STRING = "Hello World";
+    const state = createLiveWatchableState({ prop1: STRING, prop2: NUMBER });
+    globalExpect(state).toHaveProperty("prop1");
+    globalExpect(state).toHaveProperty("prop2");
+    globalExpect(state.prop1).toBe(STRING);
+    globalExpect(state.prop2).toBe(NUMBER);
+    const PREV_NUMBER = NUMBER;
+    const PREV_STRING = STRING;
+    NUMBER = 50;
+    STRING = "Hello World!!!";
+    globalExpect(state.prop1).not.toBe(STRING);
+    globalExpect(state.prop2).not.toBe(NUMBER);
+    globalExpect(state.prop1).toBe(PREV_STRING);
+    globalExpect(state.prop2).toBe(PREV_NUMBER);
+  });
+  test("should have live state getters for getter atoms", () => {
+    let NUMBER = 30;
+    let STRING = "Hello World";
+    const state = createLiveWatchableState({
+      get prop1() {
+        return STRING;
+      },
+      get prop2() {
+        return NUMBER;
+      },
+      get prop3() {
+        return this.prop2 / 2;
+      }
+    });
+    globalExpect(state).toHaveProperty("prop1");
+    globalExpect(state).toHaveProperty("prop2");
+    globalExpect(state).toHaveProperty("prop3");
+    globalExpect(state.prop1).toBe(STRING);
+    globalExpect(state.prop2).toBe(NUMBER);
+    globalExpect(state.prop3).toBe(NUMBER / 2);
+    const PREV_NUMBER = NUMBER;
+    const PREV_STRING = STRING;
+    NUMBER = 50;
+    STRING = "Hello World!!!";
+    globalExpect(state.prop1).not.toBe(PREV_STRING);
+    globalExpect(state.prop2).not.toBe(PREV_NUMBER);
+    globalExpect(state.prop3).not.toBe(PREV_NUMBER / 2);
+    globalExpect(state.prop1).toBe(STRING);
+    globalExpect(state.prop2).toBe(NUMBER);
+    globalExpect(state.prop3).toBe(NUMBER / 2);
+  });
+  test("should have live state getters for callable atoms", () => {
+    let NUMBER = 30;
+    let STRING = "Hello World";
+    const state = createLiveWatchableState({
+      prop1: () => STRING,
+      prop2: () => NUMBER,
+      prop3() {
+        return this.prop2() / 2;
+      }
+    });
+    globalExpect(state).toHaveProperty("prop1");
+    globalExpect(state).toHaveProperty("prop2");
+    globalExpect(state).toHaveProperty("prop3");
+    globalExpect(state.prop1).toBe(STRING);
+    globalExpect(state.prop2).toBe(NUMBER);
+    globalExpect(state.prop3).toBe(NUMBER / 2);
+    const PREV_NUMBER = NUMBER;
+    const PREV_STRING = STRING;
+    NUMBER = 50;
+    STRING = "Hello World!!!";
+    globalExpect(state.prop1).not.toBe(PREV_STRING);
+    globalExpect(state.prop2).not.toBe(PREV_NUMBER);
+    globalExpect(state.prop3).not.toBe(PREV_NUMBER / 2);
+    globalExpect(state.prop1).toBe(STRING);
+    globalExpect(state.prop2).toBe(NUMBER);
+    globalExpect(state.prop3).toBe(NUMBER / 2);
+  });
+});
+describe("createWatchableIdleCallbacks", () => {
+  test("should create struct of callbacks", () => {
+    const callbacks = createWatchableIdleCallbacks();
+    globalExpect(callbacks).toBeTypeOf("object");
+    globalExpect(callbacks).toHaveProperty("idle");
+    globalExpect(callbacks).toHaveProperty("resume");
+    globalExpect(callbacks.idle).toBeTypeOf("function");
+    globalExpect(callbacks.resume).toBeTypeOf("function");
+    globalExpect(callbacks.idle).toBe(noop);
+    globalExpect(callbacks.idle).toBe(callbacks.resume);
+    let idleCallback = callbacks.idle = () => {
+    };
+    let resumeCallback = callbacks.resume = {};
+    globalExpect(callbacks.idle).not.toBe(noop);
+    globalExpect(callbacks.idle).not.toBe(callbacks.resume);
+    globalExpect(callbacks.idle).toBe(idleCallback);
+    globalExpect(callbacks.resume).toBe(noop);
+    globalExpect(callbacks.resume).not.toBe(resumeCallback);
+    idleCallback = callbacks.idle = null;
+    resumeCallback = callbacks.resume = void 0;
+    globalExpect(callbacks.idle).toBe(noop);
+    globalExpect(callbacks.idle).toBe(callbacks.resume);
+    globalExpect(callbacks.idle).not.toBe(idleCallback);
+    globalExpect(callbacks.resume).not.toBe(resumeCallback);
+  });
+});

package/dist/es/utils/watchable/core/syncEffect.js

@@ -1,22 +1,26 @@
-import { struct as i } from "../../common/index.js";
-const p = (() => {
-  const r = (t) => t, c = i();
-  return (t) => {
-    if (t === void 0)
-      return r;
-    const n = [];
-    return (e) => (...s) => {
-      let o = c;
+import { struct } from "../../common/index.js";
+const createSyncEffectChain = (() => {
+  const noop = (fn) => fn;
+  const noex = struct();
+  return (effect) => {
+    if (effect === void 0)
+      return noop;
+    const chainedFnStack = [];
+    return (fn) => (...args) => {
+      let exception = noex;
       try {
-        return n.push(e), e(...s);
-      } catch (a) {
-        throw o = a;
+        chainedFnStack.push(fn);
+        return fn(...args);
+      } catch (ex) {
+        throw exception = ex;
       } finally {
-        n.pop(), n.length === 0 && o === c && t();
+        chainedFnStack.pop();
+        if (chainedFnStack.length === 0 && exception === noex)
+          effect();
       }
     };
   };
-})(), f = p;
+})();
 export {
-  f as default
+  createSyncEffectChain as default
 };

package/dist/es/utils/watchable/core/syncEffect.test.js

@@ -0,0 +1,103 @@
+import createSyncEffectChain from "./syncEffect.js";
+import { d as describe, b as beforeEach, t as test, g as globalExpect, v as vi } from "../../../../vendor-vi.a3ff54b1-5e924357.mjs";
+describe("createSyncEffectChain", () => {
+  beforeEach((context) => {
+    const effect = vi.fn();
+    Object.defineProperties(context, {
+      chain: { enumerable: true, value: createSyncEffectChain(effect) },
+      effect: { enumerable: true, value: effect }
+    });
+  });
+  test("should preserve the return value of the outermost function in the chain", ({ chain }) => {
+    const chainedFn1 = chain(() => RANDOM = Math.random());
+    const chainedFn2 = chain((value) => !!value);
+    let RANDOM = Math.random();
+    globalExpect(chainedFn1()).toBe(RANDOM);
+    globalExpect(chainedFn2("hello")).toBe(true);
+    globalExpect(chainedFn2(-0)).toBe(false);
+    const chainedFn3 = chain((value) => {
+      const boolValue = chainedFn2(value);
+      if (boolValue)
+        return chainedFn1();
+      return value == void 0 ? value : boolValue;
+    });
+    globalExpect(chainedFn3()).toBe(void 0);
+    globalExpect(chainedFn3(null)).toBe(null);
+    globalExpect(chainedFn3(NaN)).toBe(false);
+    globalExpect(chainedFn3("")).toBe(false);
+    globalExpect(chainedFn3({})).toBe(RANDOM);
+    globalExpect(chainedFn3("hello")).toBe(RANDOM);
+  });
+  test("should call effect once (synchronously) at the end of the chain", ({ chain, effect }) => {
+    const chainedFn1 = chain(vi.fn());
+    const chainedFn2 = chain(vi.fn());
+    globalExpect(effect).toBeCalledTimes(0);
+    chainedFn1();
+    globalExpect(effect).toBeCalledTimes(1);
+    chainedFn2();
+    globalExpect(effect).toBeCalledTimes(2);
+    (() => {
+      chainedFn1();
+      chainedFn2();
+      chainedFn1();
+      chainedFn2();
+      chainedFn1();
+      chainedFn1();
+    })();
+    globalExpect(effect).toBeCalledTimes(8);
+    chain(() => {
+      chainedFn1();
+      chainedFn2();
+      chainedFn1();
+      chainedFn2();
+      chainedFn1();
+      chainedFn1();
+    })();
+    globalExpect(effect).toBeCalledTimes(9);
+    chainedFn1();
+    globalExpect(effect).toBeCalledTimes(10);
+    chain(() => {
+      chainedFn1();
+      chainedFn2();
+      chainedFn1();
+    })();
+    globalExpect(effect).toBeCalledTimes(11);
+    chainedFn2();
+    globalExpect(effect).toBeCalledTimes(12);
+  });
+  test("should not call effect when there is uncaught exception within the chain", async ({ chain, effect }) => {
+    const chainedFn1 = chain(() => RANDOM = Math.random());
+    const chainedFn2 = chain((value) => !!value);
+    let EXCEPTION = "uncaught_exception";
+    let RANDOM = Math.random();
+    let COUNTER = 0;
+    globalExpect(chainedFn1()).toBe(RANDOM);
+    globalExpect(effect).toBeCalledTimes(++COUNTER);
+    globalExpect(chainedFn2("hello")).toBe(true);
+    globalExpect(effect).toBeCalledTimes(++COUNTER);
+    globalExpect(chainedFn2(-0)).toBe(false);
+    globalExpect(effect).toBeCalledTimes(++COUNTER);
+    const chainedFn3 = chain((value) => {
+      const boolValue = chainedFn2(value);
+      if (boolValue)
+        return chainedFn1();
+      if (value == void 0)
+        return value;
+      if (chainedFn1() < 0.5)
+        return boolValue;
+      throw EXCEPTION;
+    });
+    globalExpect(chainedFn3()).toBe(void 0);
+    globalExpect(effect).toBeCalledTimes(++COUNTER);
+    for await (const value of [false, 0, NaN, ""]) {
+      try {
+        await globalExpect(async () => chainedFn3(value)).rejects.toThrowError(EXCEPTION);
+        globalExpect(effect).toBeCalledTimes(COUNTER);
+      } catch {
+        globalExpect(effect).toBeCalledTimes(++COUNTER);
+      }
+    }
+    globalExpect(chainedFn3("hello")).toBe(RANDOM);
+    globalExpect(effect).toBeCalledTimes(++COUNTER);
+  });
+});

package/dist/es/utils/watchable/index.js

@@ -1,20 +1,21 @@
-import a from "./core/syncEffect.js";
-import c from "./core/Watchable.js";
-import { UNWATCH_SIGNAL as o } from "./constants.js";
-import { struct as l } from "../common/index.js";
-const r = (e) => {
-  const t = new c(e);
-  return l({
-    callback: { value: t.idleCallbacks },
-    idle: { get: () => t.idle },
-    notify: { value: t.notifyWatchers },
-    snapshot: { get: () => t.snapshot },
-    watch: { value: t.watch }
+import createSyncEffectChain from "./core/syncEffect.js";
+import __Watchable__ from "./core/Watchable.js";
+import { UNWATCH_SIGNAL } from "./constants.js";
+import { struct } from "../common/index.js";
+const watchable = (watchableAtoms) => {
+  const instance = new __Watchable__(watchableAtoms);
+  return struct({
+    callback: { value: instance.idleCallbacks },
+    idle: { get: () => instance.idle },
+    notify: { value: instance.notifyWatchers },
+    snapshot: { get: () => instance.snapshot },
+    watch: { value: instance.watch }
   });
-}, h = Object.defineProperties(r, {
-  UNWATCH: { value: o },
-  withSyncEffect: { value: a }
+};
+const watchable$1 = Object.defineProperties(watchable, {
+  UNWATCH: { value: UNWATCH_SIGNAL },
+  withSyncEffect: { value: createSyncEffectChain }
 });
 export {
-  h as default
+  watchable$1 as default
 };

package/dist/flags-41c36e13.mjs

@@ -0,0 +1,83 @@
+import { struct } from "./es/utils/common/index.js";
+import { isString } from "./es/utils/validator-utils.js";
+import { immutableProxyHandlers } from "./es/utils/common/constants.js";
+var TimeFlag = /* @__PURE__ */ ((TimeFlag2) => {
+  TimeFlag2[TimeFlag2["CURRENT"] = 1] = "CURRENT";
+  TimeFlag2[TimeFlag2["CURSOR"] = 2] = "CURSOR";
+  TimeFlag2[TimeFlag2["WEEKEND"] = 4] = "WEEKEND";
+  TimeFlag2[TimeFlag2["LINE_START"] = 8] = "LINE_START";
+  TimeFlag2[TimeFlag2["LINE_END"] = 16] = "LINE_END";
+  TimeFlag2[TimeFlag2["WITHIN_BLOCK"] = 32] = "WITHIN_BLOCK";
+  TimeFlag2[TimeFlag2["BLOCK_START"] = 64] = "BLOCK_START";
+  TimeFlag2[TimeFlag2["BLOCK_END"] = 128] = "BLOCK_END";
+  TimeFlag2[TimeFlag2["WITHIN_RANGE"] = 256] = "WITHIN_RANGE";
+  TimeFlag2[TimeFlag2["RANGE_START"] = 512] = "RANGE_START";
+  TimeFlag2[TimeFlag2["RANGE_END"] = 1024] = "RANGE_END";
+  TimeFlag2[TimeFlag2["WITHIN_SELECTION"] = 2048] = "WITHIN_SELECTION";
+  TimeFlag2[TimeFlag2["SELECTION_START"] = 4096] = "SELECTION_START";
+  TimeFlag2[TimeFlag2["SELECTION_END"] = 8192] = "SELECTION_END";
+  TimeFlag2[TimeFlag2["ALL"] = 16383] = "ALL";
+  return TimeFlag2;
+})(TimeFlag || {});
+var CalendarShiftControlFlag = /* @__PURE__ */ ((CalendarShiftControlFlag2) => {
+  CalendarShiftControlFlag2[CalendarShiftControlFlag2["PREV"] = 1] = "PREV";
+  CalendarShiftControlFlag2[CalendarShiftControlFlag2["BLOCK"] = 0] = "BLOCK";
+  CalendarShiftControlFlag2[CalendarShiftControlFlag2["FRAME"] = 2] = "FRAME";
+  CalendarShiftControlFlag2[CalendarShiftControlFlag2["PERIOD"] = 4] = "PERIOD";
+  return CalendarShiftControlFlag2;
+})(CalendarShiftControlFlag || {});
+var CalendarShiftControlsFlag = /* @__PURE__ */ ((CalendarShiftControlsFlag2) => {
+  CalendarShiftControlsFlag2[CalendarShiftControlsFlag2["PREV_PERIOD"] = 5] = "PREV_PERIOD";
+  CalendarShiftControlsFlag2[CalendarShiftControlsFlag2["PREV_FRAME"] = 3] = "PREV_FRAME";
+  CalendarShiftControlsFlag2[CalendarShiftControlsFlag2["PREV"] = 1] = "PREV";
+  CalendarShiftControlsFlag2[
+    CalendarShiftControlsFlag2["NEXT"] = 0
+    /* BLOCK */
+  ] = "NEXT";
+  CalendarShiftControlsFlag2[
+    CalendarShiftControlsFlag2["NEXT_FRAME"] = 2
+    /* FRAME */
+  ] = "NEXT_FRAME";
+  CalendarShiftControlsFlag2[
+    CalendarShiftControlsFlag2["NEXT_PERIOD"] = 4
+    /* PERIOD */
+  ] = "NEXT_PERIOD";
+  return CalendarShiftControlsFlag2;
+})(CalendarShiftControlsFlag || {});
+const createFlagsRecord = (() => {
+  const CACHE = {};
+  const FLAG_PROPS = Object.keys(TimeFlag).filter((prop) => isNaN(+prop));
+  const isFlagProp = (property) => property !== "ALL" && isString(property) && FLAG_PROPS.includes(property);
+  return (flags) => {
+    const flagsTruncated = flags & TimeFlag.ALL;
+    if (!CACHE[flagsTruncated]) {
+      CACHE[flagsTruncated] = new Proxy(
+        struct({
+          valueOf: { value: () => flagsTruncated }
+        }),
+        {
+          ...immutableProxyHandlers,
+          get: (target, property) => {
+            switch (property) {
+              case "valueOf":
+                return target.valueOf;
+              case Symbol.toStringTag:
+                return "_";
+              default:
+                if (!isFlagProp(property))
+                  return;
+            }
+            return flagsTruncated & TimeFlag[property] ? 1 : void 0;
+          }
+        }
+      );
+    }
+    return CACHE[flagsTruncated];
+  };
+})();
+export {
+  CalendarShiftControlsFlag as C,
+  TimeFlag as T,
+  CalendarShiftControlFlag as a,
+  createFlagsRecord as c
+};