Fy 212 complete work 구현 (#36)

* feat(core): childfiber내에서 reconcileChildFibers뼈대 구현

reconcileChildFibers의 뼈대를 구현하였습니다.
이는 ChildReconciler가 반환하는 함수로써 childReconciler내부의 헬퍼들을 이용하여
child를 재조정하는데 사용됩니다. 여기서 ChildReconciler의 인자인 shouldTrackSideEffects를
통해 마운트를 하고 있는지, update를 하고있는지 분리할 수 있습니다.
reconcileChildFibers는 일반적으로 파이버를 생성하고(reconcile)이를 place와 같은 방식으로
배치까지(sideEffect를 가함) 진행합니다.
또한 이 함수는 재귀적이지 않습니다. 이말은 모든 자식을 풀어서 제공하는게 아니라 현재 레벨까지
만 재조정을 한후 리턴하고 이후에 다시 performUniofwork가 호출됨으로써 자식까지 타고 가면서 처리되는
구조를 취합니다.

* feat(fiber): ReconcileSingleElement를 위한 헬퍼함수들 구현

해당 함수들을 구현했습니다. 여기서 주의할 것은 삭제나 이런것이
일어났더라도 실제 삭제가 아니라 sideEffect로 남겨두고 나중에 처리되는걸 의미하는걸
주의해야합니다.

* feat(fiber,type): ElemenType,type에 대한 설명수정 및 reconcile관련 헬퍼함수(update)와 childReconcile구현

ElemntType,Type에 대한 설명:
해당 설명이 잘못되어 있어서 수정하고 이는 중요한 참고사항입니다.
ElementType
ElementType:은 재조정(reconcile)상황에서 비교를 진행할떄 매칭해나가면서 신원을 확인할떄
사용됩니다. fiber.ElementType === element.type이런식으로 비교를 해나가는데
여기서 element는 RfsElement로 jsx를 통해서 들어오면서 생기는 type에 해당하고
fiber내부에서 이것과 비교를 하기위해 신원확인을 위해 사용합니다.
Type:
내부정으로 재조정후에 실제 컴포넌트를 불러야되거나, context를 확인해야되는등
내부적으로 처리될떄 사용되는 type입니다.

Reconcile 관련:
재조정관련해서 update에 관련된 함수가 많은데 기본적으로
newChild가 null이 아닌경우 type비교를 통해서 재사용할 수 있으면 재사용하고
아니면 만들어서 받은 것을 통해서 파이버를 만들어서 뱉어준다라고 생각하면됩니다.

placeChild 관련:
기본적으로 파이버는 list구조를 띄고 파이버 내에서 이동이란 list내에서 이동을
뜻합니다. 그렇다라는 것은 자신이 가르키고 있는 next가 바뀌는 상황을 의미하고
이럴떄만 sideEffect-PlaceMent를 붙여줍니다. 자세한 내용은 해당 코드의 주석을 참조하시길 바랍니다.
reconcileChildrenArray 관련:
해당 알고리즘 로직은 먼저 현재 파이버 리스트가 변경되지 않았다 라고 가정하고 진행하다가
변경이 가해지면 phase2로 나머지 친구들을 map에 넣고 그것을 통해 비교하는 로직으로 진행됩니다.
자세한 로직은 코드를 참조하면 됩니다.

* feat(fiber): reconcileChildrenIterator구현

단순히 reconcileChildrenArray의 로직을
이터러블로 수정하고, 해당 이터러블이 이터러블인지, 그 이터러블이
이터레이터를 제공하는지 에대한 로직만 추가로 들어가있을 뿐입단순히 reconcileChildrenArray의 로직을
이터러블로 수정하고, 해당 이터러블이 이터러블인지, 그 이터러블이 이터레이터를 제공하는지
확인하는 부분만 추가로 있을 뿐입니다. 작동알고리즘은 childrenArray부분을 확인하면 됩니다.

* FY-212/feat(fiber): reconcileChildFibers export

외부에 export하고, mountChild할떄는 false를 reconcile할떄 true사용

* FY-212/fix(core,hooks): 기본의 주석이나, import관련 명세 수정

import가 안되어 있던것이나, hook관련해서 설명이 좀 적은 것들을
주석을 추가하였습니다.

* FY-212/fix(type, hooks): 관련된 설명, typeImport이슈 해결

관련된 타입 import해결 이슈를 해결하고
훅 내부적인 로직을 설명하는 부분관련 주석을 추가하였습니다.

---------

Co-authored-by: daekuelee <[email protected]>

srcs/Reconciler/reconciler.js

@@ -5,7 +5,7 @@
  */
 
 import { enqueueUpdate, createUpdate } from "../core/UpdateQueue.js";
-import { scheduleWork } from "../work/workLoop.js";
+import { scheduleWork, requestCurrentTimeForUpdate, computeExpirationForFiber } from "../work/workloop.js";
 /**
  *
  * @param {TRfsNodeList} element @see 파일경로: [TRfsType.js](srcs/type/TRfsType.js)
@@ -24,7 +24,7 @@ import { scheduleWork } from "../work/workLoop.js";
 //*-*ReactDOMRoot.render(<App/>)
 //*-**-*updateContainer(<App/>, root, null, null)
 
-//TODO: parentComponent의 경우 Portal과 서버사이드 렌더링을 위한 것으로 보임.
+//NOTE: parentComponent의 경우 Portal과 서버사이드 렌더링을 위한 것으로 보임.
 //TODO: 만약 해당 인자가 정말 그것 두가지만을 위한 것이라면 삭제 예정.
 export const updateContainer = (
     element,
@@ -34,15 +34,10 @@ export const updateContainer = (
 ) => {
     //fiberRoot.current를 통해 현재 FiberRoot의 파이버를 가져옵니다.
     const current = container.current;
-    //TODO: implement requestCurrentTimeForUpdate
     //현재 리액트에서의 시간을 가져옵니다. 이는 뒤에서 우선순위를 정할때 사용되는 ExpirationTime을 계산할때 사용됩니다.
     const currentTime = requestCurrentTimeForUpdate();
-    //TODO: 구현 안해도 되는지 확인 필요
-    // const suspenseConfig = requestCurrentSuspenseConfig();
-    //TODO: computeExpirationForFiber 구현 필요
     //앞선 currentTime을 기반으로 해당 파이버의 우선순위와 관련된 정보인 ExpirationTime을 계산합니다.
     const expirationTime = computeExpirationForFiber(currentTime, current);
-
     //TODO: 정확히 여기가 어떤 문맥을 가지는 지 정의 필요->아마 구현 안해도 될것으로보임
     //예측 :: 부모 컴포넌트의 문맥을 가져오는 것으로 보임
     // const context = getContextForSubtree(parentComponent);

srcs/core/UpdateQueue.js

@@ -40,6 +40,7 @@ export class updateState {
     /**
      *
      * @see {TUpdateState} updateState @see :파일경로 srcs/type/TUpdateQueue.js
+     * @type {import("../../type/TUpdateQueue.js").TUpdateState} updateState
      */
     constructor(expirationTime) {
         this.expirationTime = expirationTime;
@@ -225,6 +226,27 @@ const getStateFromUpdate = (update, prevState, nextProps) => {
     }
     return prevState;
 };
+
+/**
+ *
+ * @param {TFiber} workInProgress
+ * @param {import("../../type/TUpdateQueue.js").TUpdateQueueState} queue
+ * @returns {import("../../type/TUpdateQueue.js").TUpdateQueueState}
+ * @description alternate가 존재 하는데 alternate의 queue와 wipQueue가 같다면
+ * @description 큐를 복제하여 새로운 큐를 만들어준다. sharingSturucture를 processing할떄는 연결을 끊어야하기 때문이다.
+ */
+const ensureWorkInProgressQueueIsAClone = (workInProgress, queue) => {
+    const current = workInProgress.alternate;
+    if (current !== null) {
+        //이미 alternate가 있다면
+        if (queue === current.updateQueue) {
+            //이미 같은 큐를 가지고 있다면
+            //큐를 복제하여 새로운 큐를 만들어준다.
+            queue = workInProgress.updateQueue = cloneUpdateQueue(queue);
+        }
+    }
+    return queue;
+};
 /**
  *
  * @param {import("../../type/TFiber.js").TFiber} fiber
@@ -237,7 +259,6 @@ export const processUpdateQueue = (workInProgress, queue, props, renderExpiratio
     // hasForceUpdate = false;
 
     //진행하기 앞서, currentUpdateQueue와의 연결떄문에 현재 wipQueue를 복제한다.
-    //TODO: ensureWorkInProgressQueueIsAClone 구현해야함
     queue = ensureWorkInProgressQueueIsAClone(workInProgress, queue);
 
     //updateQueue를 처리하면서 나중에 갱신을 위한 변수들이다.

srcs/core/createRoot.js

@@ -83,7 +83,7 @@ const ReactDOMRoot = class {
      */
     render(children) {
         const root = this._internalRoot;
-        updateContainer(children, root, null, null);
+        updateContainer(children, root, null);
     }
 };
 /**

srcs/fiber/childFiber.js

@@ -117,11 +117,18 @@ const ChildReconciler = (shouldTrackSideEffects) => {
      * @description 기본적으로 index를 바꾸는 행위를 하며, placeMentTag(사이드 이팩트를 가함)을 할지 안할지를 정한다
      * @description 여기서 배치란 list구조 내에서의 배치를 의미한다(fiber가 list구조 임을 기억하자)
      * @description 실제 리스트내에서 배치가 바뀌는 친구만 placementTag를 붙인다(sideEffect)
-     * @description 예를 들어 1->2->3 ==> 2->3->1과 같은 경우 자신이 가르키고 있는 next포인터가 바뀌는 친구만 배치가 바뀌었다고 취급한다.
-     * @description 해당 경우는 1만 바뀌었음으로 1에 대해서만 placementTag를 붙인다.
-     * @description 최악의 케이스로는 1->2->3 ==> 3->1->2로 이동시키는 경우이다. 1번 뺴고 모두 오른쪽화살표가 바꼈음으로 2개를 이동시켜야된다.
-     * @description 해당 배치가 바뀐친구들만 sideEffect를 가하는 방식은 lastPlacedIndex를 통해 이루어진다.
+     * @description 이 리스트 구조내에서 자리를 바꿈에 있어서 해당 알고리즘은 가장 많은 방향이 같은 그룹(연속된)을 남겨서 적게 이동을 시키길 원한다.
+     * @description 그것에 대한 해답으로, newChild배열의 처음을 기준으로 가장 길게 진행 방향으로 방향이 같은 그룹은 이동을 하지 않아도 된다
+     * @description 라고 보고 나머지 그룹을 이동시킨다.
+     * @description 예 1) 1->2->3->4->5 ==> 3->4->5->1->2로 바뀌는 경우인 새 첫자식인 3으로 부터 (3,4,5)가 방향이 일치함으로 이동을
+     * @description 하지 않아도 된다라고 보고 1,2를 새로 배치시킨다.
+     * @description 예 2) 1->2->3->4->5 ==> 3->5->4->1->2로 바뀌는 경우 (3,5)까지가 방향이 같은 그룹으로 보고 (3,5)를 이동시키지 않고
+     * @description (4,1,2)를 이동시킨다.
+     * @description 해당 알고리즘은 특성상 반전에 취약하다
+     * @description 예 3) 1->2->3->4->5 ==> 5->4->3->2->1로 바뀌는 경우 (5로)부터 방향이 같은 그룹이 하나도 없음으로 5만 이동을 시키지 않고
+     * @description 나머지를 이동시킨다. ==> 이는 반전과 같은 구조보다는 방향을 일치 시키는 구조가 좀 더 많이 일어난다라고 가정한 것이다.
      */
+    //TODO: 배치 설명 가장 list내에서 인접한 그룹을 많이 남겨서 적게 이동한다라는 식으로 설명바꾸기
     const placeChild = (newFiber, lastPlacedIndex, newIndex) => {
         newFiber.index = newIndex;
         if (!shouldTrackSideEffects) {
@@ -545,6 +552,8 @@ const ChildReconciler = (shouldTrackSideEffects) => {
             //그리고 마지막으로 배치가 바뀌지 않은 파이버의 인덱스를 가르키는 변수를 업데이트해야됨
             //NOTE: place-배치란 list에서의 배치를 의미함-> 이것은 array에서 index를 바꾸는 것이
             //NOTE:아닌 인접한것을 기준을 의미함 (fiber 자체가 list구조이므로)
+            //NOTE: placeChild의 알고리즘은 placeChild를 참고하면 
+
             lastPlacedIndex = placeChild(newFiber, lastPlacedIndex, newIdx);
 
             //딱 한번만 resultFirstFiber를 세팅해야됨
@@ -764,7 +773,8 @@ const ChildReconciler = (shouldTrackSideEffects) => {
                         element.type === RFS_FRAGMENT_TYPE ? element.props.children : element.props,
                         expirationTime
                     );
-                    existing.ref = elemnt.ref;
+
+                    existing.ref = element.ref;
                     existing.return = returnFiber;
                     return existing;
                 } else {
@@ -858,13 +868,11 @@ const ChildReconciler = (shouldTrackSideEffects) => {
 
         //newChild가 배열일때
         if (isArray(newChild)) {
-            //TODO: reconcileChildrenArray구현
             return reconcileChildrenArray(returnFiber, currentFirstChild, newChild, expirationTime);
         }
 
         //newChild가 iterable일때
         if (getIteratorFn(newChild)) {
-            //TODO: reconcileChildrenIterator구현
             return reconcileChildrenIterator(returnFiber, currentFirstChild, newChild, expirationTime);
         }
 
@@ -922,3 +930,6 @@ export const cloneChildFibers = (current, workInProgress) => {
     //마지막 자식의 sibling을 null로 만들어줍니다.
     newChild.sibling = null;
 };
+
+export const reconcileChildFibers = ChildReconciler(true);
+export const mountChildFibers = ChildReconciler(false);

srcs/fiber/fiberRoot.js

@@ -22,7 +22,9 @@ const FiberRootNode = class {
         //Todo: TimeoutHandle의 정확한 명세가 필요합니다.
         this.timeoutHandle = null;
         this.context = null;
-        this.pendingContext = null;
+        //NOTE: disableLegacyContext와 그리고 getContextForSubtree관련있는데 이건 서브트리에서 받아와서
+        //NOTE: 렌더하는거랑 관련있는듯 => 구현 x
+        // this.pendingContext = null;
         this.callbackNode = null;
         this.callbackPriority = null;
         this.callbackExpirationTime = NoWork;

srcs/hooks/core/renderWithHooks.js

@@ -59,8 +59,16 @@ const renderWithHooks = (current, workInProgress, Component, props, refOrContext
     let children = Component(props, refOrContext);
 
     // render phase시에 update가 발생했다면 해당 Component를 다시 렌더링합니다.
+    // NOTE: renderphaseUpdate란 예를들어
+    // NOTE: function component ({props}) {
+    // NOTE:     const [state, setState] = useState(0);
+    // NOTE:     setState(1);
+    // NOTE:     setState(2);
+    // NOTE:     return <div>{state}</div>
+    // NOTE:  이런꼴일떄 컴포넌트 코드 안에 setState코드가 있어서 dispatchAction이 여기선 두번 불릴떄 일어나는 상황이다.
     if (hookRenderPhase.didScheduleRenderPhaseUpdate) {
         do {
+            //NOTE: (daegulee)->여기서 만약에 무한으로 돌면 Throw던지는게 좋지 않을까요?? 예를 들어 40번정도면 에러로그를 찌
             hookRenderPhase.didScheduleRenderPhaseUpdate = false;
             hookRenderPhase.numberOfReRenders += 1;
 

srcs/hooks/shared/dispatchAction.js

@@ -24,6 +24,7 @@ import enqueueRenderPhaseUpdate from "./enqueueRenderPhaseUpdate.js";
  *  해당 65번째 줄의 함수는 이후 구현에 따라 변경될 수 있습니다. react Source에서 render phase일 시에
  *  enqueueRenderPhaseUpdate를 호출하고 있습니다.
  */
+
 const dispatchAction = (fiber, queue, action) => {
     const alternate = fiber.alternate;
 
@@ -38,6 +39,12 @@ const dispatchAction = (fiber, queue, action) => {
 
         const update = createHookUpdate(hookExpirationTime.renderExpirationTime, null, action, null, null, null);
 
+        //NOTE: 컴포넌트 내의 여러 useState와 useReducer가 존재 할 수 있는데
+        //NOTE: 안내를 할라면 map이 필요한가 ?
+        //NOTE: 위의 주석이 맞다. 정확이는 일단 dispatchAction은 hook을 인자로 안받아서
+        //NOTE: 훅에 대한 신원 확인을 하려면, hook과 대응되는 hook.queue를 통해 신원확인을 해야됨
+        //NOTE: 그리고 나중에 useReducer에서 빠르게 자신의 현재 hook에 대한 update를 찾기 위해서
+        //NOTE: 이렇게 진행
         if (hookRenderPhase.renderPhaseUpdates === null) {
             hookRenderPhase.renderPhaseUpdates = new Map();
         }
@@ -70,10 +77,24 @@ const dispatchAction = (fiber, queue, action) => {
         enqueueRenderPhaseUpdate(queue, update);
 
         // TODO: refactor this statement, isNoWorkOnBothFiber
+        //NOTE: 이게 굉장히 복잡한데 처음생성될 때는 fiberExpirationTime이 Nowork임 정확히는
+        //NOTE: 처음 바인드 될떄는, 이유는 beginwork에서 beginPhase넘어가기 전에 wip.expirtationTime을 NoWork로 설정하는데
+        //NOTE: 이게 hookcore.currentlyRenderingFiber으로 전달되고
+        //NOTE: 바인드할떄 currentRenderingFiber를 바인드하기 떄문에 처음에는 ExpirtationTime이 NoWork임
+        //NOTE: 그리고 마운트가 막 된상황이면 alternate가 null이기 떄문에 이것도 NoWork임.
+        //NOTE: 그리고 이 파이버가 update(expirationTime갱신)이 없으면 만족
+
+        //NOTE:주석 의미 그대로 update가 들어왔으면 expirationTime이 들어왔을건데 둘다 없으니까 없다라고 하는듯
+        //NOTE:해당 파이버에 대해서 가해진 사이드 이펙트가 없을거니까 신경 안쓰고 선제적으로 계산을 가할 수 있따라는것 같다.
+        //NOTE:좀더 정확히는 클릭해서 이벤트를 가했는데, 해당 친구가 업데이트가 없는 상황이면, 선제적으로 계산해서 그 결과가
+        //NOTE:상태를 바꾸지 않았다면 렌더링을 할 필요가 없다는 것이다.
+        //NOTE:달라졌으면 나중에 사용할 수 있게 eagerState에다가 저장해놓고 나중에 하나씩 꺼내서 그 결과를 사용할 수 있게 한다.
+        //NOTE:만약 렌더 도중에 reducer가 조건문에 의해서 바뀌면 이것을 사용하지 못함으로 eageReducer === reducer를 비교하는듯
         if (fiber.expirationTime === NoWork && (alternate === null || alternate.expirationTime === NoWork)) {
             // The queue is currently empty, which means we can eagerly compute the
             // next state before entering the render phase. If the new state is the
             // same as the current state, we may be able to bail out entirely.
+            //NOTE:여기서의 Bailout은 scheduleWork를 호출하지 않는다는 것인듯.
             const lastRenderedReducer = queue.lastRenderedReducer;
             if (lastRenderedReducer !== null) {
                 try {

srcs/hooks/useReducer/useReducerImpl.js

@@ -30,7 +30,7 @@ const updateReducerImpl = (hook, reducer) => {
     const queue = hook.queue;
     queue.lastRenderedReducer = reducer;
 
-    // render-phase update (1번째 분기)
+    // render-phase update (1번째 분기) NOTE: render phase update === component안에서 dispatch를 호출했을 때
     if (hookRenderPhase.numberOfReRenders > 0) {
         // render-phase update
         // This is a re-render. Apply the new reduer phase updates to the previous

srcs/scheduler/schedulerInterface.js

@@ -15,6 +15,7 @@ const {
     NormalPriorityImpl: schedulerNormalPriority,
     LowPriorityImpl: schedulerLowPriority,
     IdlePriorityImpl: schedulerIdlePriority,
+    getCurrentPriorityLevelImpl: schedulerGetCurrentPriorityLevel,
 } = Scheduler;
 
 import {

srcs/work/beginWork.js

@@ -1,4 +1,3 @@
-import { update } from "lodash";
 import { prepareToReadContext, propagateContextChange, pushProvider, readContext } from "../context/newContext.js";
 import calculateChangedBits from "../context/shared/calculateChangedBits.js";
 import hasContextChanged from "../context/shared/hasContextChanged.js";
@@ -14,11 +13,12 @@ import {
 } from "../const/CWorkTag.js";
 import { Placement, PerformedWork } from "../const/CSideEffectFlags.js";
 import { Update as UpdateEffect, Passive as PassiveEffect } from "../const/CSideEffectFlags.js";
-import { cloneChildFibers } from "../fiber/childFiber.js";
+import { cloneChildFibers, reconcileChildFibers, mountChildFibers } from "../fiber/childFiber.js";
 import renderWithHooks from "../hooks/core/renderWithHooks.js";
 import { shallowEqual } from "../shared/sharedEqual.js";
-import { markUnprocessedUpdateTime } from "./workLoop.js";
+import { markUnprocessedUpdateTime } from "./workloop.js";
 import { pushHostContainer, pushHostContext } from "../fiber/fiberHostContext.js";
+import { processUpdateQueue } from "../core/UpdateQueue.js";
 
 /**
  *

srcs/work/workloop.js

@@ -21,6 +21,7 @@ import {
     // flushSyncCallbackQueue,
     // scheduleSyncCallback,
 } from "../scheduler/schedulerInterface.js";
+import { beginWork } from "../work/beginWork.js";
 
 import {
     NoPriority,
@@ -153,8 +154,8 @@ let currentEventTime = NoWork;
  * @param {TExpirationTime} expirationTime @see 파일경로: [TExpirationTime.js](srcs/type/TExpirationTime.js)
  */
 export const markUnprocessedUpdateTime = (expirationTime) => {
-    if (expirationTime > workInProgressRootNextUnprocessedUpdateTime) {
-        workInProgressRootNextUnprocessedUpdateTime = expirationTime;
+    if (expirationTime > currentWorkContext.workInProgressRootNextUnprocessedUpdateTime) {
+        currentWorkContext.workInProgressRootNextUnprocessedUpdateTime = expirationTime;
     }
 };
 
@@ -435,6 +436,7 @@ const completeUnitOfWork = (unitOfWork) => {
         const returnFiber = currentWorkContext.workInProgress.return;
 
         //TODO: completeWork
+        //호스트 환경과 관련된 부분의 대한 일을 처리합니다.
         const next = completeWork(current, currentWorkContext.workInProgress, currentWorkContext.renderExpirationTime);
         //TODO: resetChildExpirationTime
         resetChildExpirationTime(currentWorkContext.workInProgress);
@@ -507,7 +509,6 @@ const completeUnitOfWork = (unitOfWork) => {
 const performUnitOfWork = (unitOfWork) => {
     const current = unitOfWork.alternate;
 
-    //TODO: beginWork
     //beginwork를 수행해서 다음 수행할 작업을 반환합니다.
     //beginwork에서 bailout이나, update~로 분기됩니다. 만약 next가 leaf이면 null을 반환합니다.
     let next = beginWork(current, unitOfWork, currentWorkContext.renderExpirationTime);

type/TContext.js

@@ -25,4 +25,3 @@ const TContext = {
  * @description context가 없을떄 사용하는 타입을 정의합니다.
  */
 const TNoContextT = {};
-export default TContext;

type/TContextItem.js

@@ -10,5 +10,3 @@ const TContextItem = {
     observedBits: 0,
     next: null,
 };
-
-export default TContextItem;

type/TDependencies.js

@@ -13,5 +13,3 @@ const TDependencies = {
     firstContext: TContextItem | null,
     responders: Map(ReactEventResponder, ReactEventResponderInstance | null),
 };
-
-export default TDependencies;

type/TDomType.js

@@ -1,10 +1,7 @@
-import { RfsNodeList } from "./TRfsType";
-import { TFiberRoot } from "./TFiberRoot";
-
 /**
  * @typedef {Element & {_rfsRootContainer: TDOMRootType}} DOMContainer
  */
-export const DOMContainer =
+const DOMContainer =
     Element &
         {
             _rfsRootContainer: TDOMRootType,
@@ -17,7 +14,7 @@ export const DOMContainer =
 /**
  * @typedef {Object} TDOMRootType
  */
-export const TDOMRootType = {
+const TDOMRootType = {
     /**
      * @param {RfsNodeList} @type {RfsNodeList} -> ReactNodeList
      */

type/TExpirationTime.js

@@ -16,15 +16,15 @@
 //31비트인 이유 :
 // VM(실제로는 대부분 V8)은 가능한 경우 정수 유형에 최적화하려고 하기 때문에 32비트 시스템에서 단일 32비트 단어에 맞추기를 원할 때가 있습니다.
 // 이 숫자로 인해 이러한 가정을 포기하고 슬롯을 확장해야 할 수도 있습니다.
-export const MAX_SIGNED_31_BIT_INT = 1073741823;
-export const TExpirationTime = Number; // only for editor to recognize the type
+const MAX_SIGNED_31_BIT_INT = 1073741823;
+const TExpirationTime = Number; // only for editor to recognize the type
 //만료시간 자체의 값 자체를 우선순위 값으로 바라볼 수 있다.
 //Sync가 가장 우선순위가 크게 있음으로 가능한 가장 큰 수인 MAX_SIGNED_31_BIT_INT를 사용한다.
 //그다음 우선순위는 Batched로 그다음으로 큰 수인 MAX_SIGNED_31_BIT_INT - 1을 사용한다.
 //expiration Time의 계산식은 general하게는 Sync - performance.now()로 하고 싶었는데-> 이러면 Sync,Batched crash날수 있으니까
 //MAGIC_NUMBER_OFFSET = Batched - 1을 사용한다. expirationTime = MAGIC_NUMBER_OFFSEt - performance.now()/10;
-export const NoWork = 0;
-export const Idle = 1;
-export const Sync = MAX_SIGNED_31_BIT_INT;
-export const Batched = Sync - 1;
-export const MAGIC_NUMBER_OFFSET = Batched - 1;
+const NoWork = 0;
+const Idle = 1;
+const Sync = MAX_SIGNED_31_BIT_INT;
+const Batched = Sync - 1;
+const MAGIC_NUMBER_OFFSET = Batched - 1;