// wx.login({})  => isQyWx ? wx.qy.login : wx.login

// 小程序启动文件
const isWxEnv = wx.getSystemInfoSync()?.environment === 'wxwork';

(function () {
  wx = new Proxy(wx, {
    get(target, propKey, recevier) {
      if (isWxEnv && propKey === 'login') {
        return wx.qy.login;
      }
      return target[propKey];
    }
  })
})();

headers: {
    'Access-Control-Allow-Origin': '*',
},

{
  requestDidStart(requestContext) {
    return {
      willSendResponse(requestContext) {
        const { data } = requestContext.response;
        const host = requestContext.request.http.headers.get('host');
        if (data?.login?.token) {
          requestContext.response.http.headers.set(
             'Set-Cookie', '_t=' + data?.login?.token
                + '; Domain=' + domain + '; Path=/;'
           );
       }

        if (data?.operation) {
            requestContext.response.http.status = 302;
       }
    };
  }
}

// 假设contentBlock的text是hello
// contentBlock.getCharacterList() 返回的则是
// [
//     {style: [], entity: null},
//     {style: [], entity: null},
//     {style: [], entity: null},
//     {style: [], entity: null},
//     {style: [], entity: null},
// ]
// 数组中 第一个元素表示 'h'这个字符，他的style是个[]，并且没有entity

const rewiredPath = require.resolve('@storybook/preset-create-react-app/dist/helpers/getReactScriptsPath');
const rewired = require(rewiredPath);

require.cache[rewiredPath].exports = {
    getReactScriptsPathWithYarnPnp: rewired.getReactScriptsPathWithYarnPnp,
    getReactScriptsPath: () => {
        const path = require.resolve('react-scripts/package.json');
        return path;
    },
};


const presets = require('@storybook/preset-create-react-app');

exports = {
    ...presets
};

export const Layer = 'Layer';
export const FastLayer = 'FastLayer';
export const Group = 'Group';
export const Label = 'Label';
export const Rect = 'Rect';
export const Circle = 'Circle';
export const Ellipse = 'Ellipse';
export const Wedge = 'Wedge';
export const Line = 'Line';
export const Sprite = 'Sprite';
export const Image = 'Image';
export const Text = 'Text';
export const TextPath = 'TextPath';
export const Star = 'Star';
export const Ring = 'Ring';
export const Arc = 'Arc';
export const Tag = 'Tag';
export const Path = 'Path';
export const RegularPolygon = 'RegularPolygon';
export const Arrow = 'Arrow';
export const Shape = 'Shape';
export const Transformer = 'Transformer';

import ReactFiberReconciler from 'react-reconciler';

const KonvaRenderer = ReactFiberReconciler(HostConfig);

import React from 'react';
import { Text } from 'react-konva';

const Demo = () => {
  return <Text text="hello" />
};

import React from 'react';
import { Text } from 'react-konva';

const Demo = () => {
  return React.createElement('Text', {
    text: 'hello'
  }, null);
};

 /**
  * This method should return a newly created node. For example, the DOM renderer would call `document.createElement(type)` here and then set the properties from `props`.
  *
  * You can use `rootContainer` to access the root container associated with that tree. For example, in the DOM renderer, this is useful to get the correct `document` reference that the root belongs to.
  *
  * The `hostContext` parameter lets you keep track of some information about your current place in the tree. To learn more about it, see `getChildHostContext` below.
  *
  * The `internalHandle` data structure is meant to be opaque. If you bend the rules and rely on its internal fields, be aware that it may change significantly between versions. You're taking on additional maintenance risk by reading from it, and giving up all guarantees if you write something to it.
  *
  * This method happens **in the render phase**. It can (and usually should) mutate the node it has just created before returning it, but it must not modify any other nodes. It must not register any event handlers on the parent tree. This is because an instance being created doesn't guarantee it would be placed in the tree — it could be left unused and later collected by GC. If you need to do something when an instance is definitely in the tree, look at `commitMount` instead.
*/

// createInstance 只列出了核心代码
export function createInstance(type, props, internalInstanceHandle) {
  let NodeClass = Konva[type]; // type 是 Layer、Group 等 会找到
  const instance = new NodeClass(propsWithoutEvents);
  applyNodeProps(instance, propsWithOnlyEvents); // 将event设置到节点上，并绘制在canvas上。
  return instance;
}

/**
  * Same as `createInstance`, but for text nodes. If your renderer doesn't support text nodes, you can throw here.
*/

/**
 * This method should mutate the `parentInstance` and add the child to its list of children. For example, in the DOM this would translate to a `parentInstance.appendChild(child)` call.
 *
 * This method happens **in the render phase**. It can mutate `parentInstance` and `child`, but it must not modify any other nodes. It's called while the tree is still being built up and not connected to the actual tree on the screen.
*/

export function appendInitialChild(parentInstance, child) {
  // parentInstance 是 Knova的node
  parentInstance.add(child);
  // parentInstance 绘制，类似于DOM中的操作DOM
  updatePicture(parentInstance);
}

 /**
  * In this method, you can perform some final mutations on the `instance`. Unlike with `createInstance`, by the time `finalizeInitialChildren` is called, all the initial children have already been added to the `instance`, but the instance itself has not yet been connected to the tree on the screen.
  *
  * This method happens **in the render phase**. It can mutate `instance`, but it must not modify any other nodes. It's called while the tree is still being built up and not connected to the actual tree on the screen.
  *
  * There is a second purpose to this method. It lets you specify whether there is some work that needs to happen when the node is connected to the tree on the screen. If you return `true`, the instance will receive a `commitMount` call later. See its documentation below.
  *
  * If you don't want to do anything here, you should return `false`.
*/

// 不处理 `commitMount`
export function finalizeInitialChildren(domElement, type, props) {
  return false;
}

/**
  * React calls this method so that you can compare the previous and the next props, and decide whether you need to update the underlying instance or not. If you don't need to update it, return `null`. If you need to update it, you can return an arbitrary object representing the changes that need to happen. Then in `commitUpdate` you would need to apply those changes to the instance.
  *
  * This method happens **in the render phase**. It should only *calculate* the update — but not apply it! For example, the DOM renderer returns an array that looks like `[prop1, value1, prop2, value2, ...]` for all props that have actually changed. And only in `commitUpdate` it applies those changes. You should calculate as much as you can in `prepareUpdate` so that `commitUpdate` can be very fast and straightforward.
  *
  * See the meaning of `rootContainer` and `hostContext` in the `createInstance` documentation.
*/

export function prepareUpdate(domElement, type, oldProps, newProps) {
  return UPDATE_SIGNAL;
}

/**
 * Some target platforms support setting an instance's text content without manually creating a text node. For example, in the DOM, you can set `node.textContent` instead of creating a text node and appending it.
 *
 * If you return `true` from this method, React will assume that this node's children are text, and will not create nodes for them. It will instead rely on you to have filled that text during `createInstance`. This is a performance optimization. For example, the DOM renderer returns `true` only if `type` is a known text-only parent (like `'textarea'`) or if `props.children` has a `'string'` type. If you return `true`, you will need to implement `resetTextContent` too.
  *
  * If you don't want to do anything here, you should return `false`.
  *
  * This method happens **in the render phase**. Do not mutate the tree from it.
*/

export function shouldSetTextContent(type, props) {
  return false;
}

/**
 * This method lets you return the initial host context from the root of the tree. See `getChildHostContext` for the explanation of host context.
 *
 * If you don't intend to use host context, you can return `null`.
 *
 * This method happens **in the render phase**. Do not mutate the tree from it.
*/

export function getRootHostContext() {
  return NO_CONTEXT;
}

/**
  * Host context lets you track some information about where you are in the tree so that it's available inside `createInstance` as the `hostContext` parameter. For example, the DOM renderer uses it to track whether it's inside an HTML or an SVG tree, because `createInstance` implementation needs to be different for them.
  *
  * If the node of this `type` does not influence the context you want to pass down, you can return `parentHostContext`. Alternatively, you can return any custom object representing the information you want to pass down.
  *
  * If you don't want to do anything here, return `parentHostContext`.
  *
  * This method happens **in the render phase**. Do not mutate the tree from it.
*/

export function getChildHostContext() {
  return NO_CONTEXT;
}

/**
         * Determines what object gets exposed as a ref. You'll likely want to return the `instance` itself. But in some cases it might make sense to only expose some part of it.
         *
         * If you don't want to do anything here, return `instance`.
*/

export function getPublicInstance(instance) {
  return instance;
}

/**
 * This method lets you store some information before React starts making changes to the tree on the screen. For example, the DOM renderer stores the current text selection so that it can later restore it. This method is mirrored by `resetAfterCommit`.
 *
 * Even if you don't want to do anything here, you need to return `null` from it.
*/

export function prepareForCommit() {
  return null;
}

/**
  * This method is called right after React has performed the tree mutations. You can use it to restore something you've stored in `prepareForCommit` — for example, text selection.
  *
  * You can leave it empty.
*/

export function resetAfterCommit() {
  // Noop
}

/**
 * You can proxy this to `setTimeout` or its equivalent in your environment.
*/

export const scheduleTimeout = setTimeout;

/**
  * You can proxy this to `clearTimeout` or its equivalent in your environment.
*/

export const cancelTimeout = clearTimeout;

/**
  * This method should mutate the `parentInstance` and add the child to its list of children. For example, in the DOM this would translate to a `parentInstance.appendChild(child)` call.
  *
  * Although this method currently runs in the commit phase, you still should not mutate any other nodes in it. If you need to do some additional work when a node is definitely connected to the visible tree, look at `commitMount`.
*/

export function appendChild(parentInstance, child) {
  // step1: 处理节点 已有的 => 设置到最上层； 没有的 => add
  if (child.parent === parentInstance) {
    child.moveToTop();
  } else {
    parentInstance.add(child);
  }
  // 批量绘制 
  updatePicture(parentInstance);
}

/**
  * This method should mutate the `parentInstance` and place the `child` before `beforeChild` in the list of its children. For example, in the DOM this would translate to a `parentInstance.insertBefore(child, beforeChild)` call.
  *
  * Note that React uses this method both for insertions and for reordering nodes. Similar to DOM, it is expected that you can call `insertBefore` to reposition an existing child. Do not mutate any other parts of the tree from it.
*/

export function insertBefore(parentInstance, child, beforeChild) {
  // child._remove() will not stop dragging
  // but child.remove() will stop it, but we don't need it
  // removing will reset zIndexes
  child._remove();
  parentInstance.add(child);
  child.setZIndex(beforeChild.getZIndex());
  updatePicture(parentInstance);
}

/**
 * This method should mutate the `parentInstance` to remove the `child` from the list of its children.
 *
 * React will only call it for the top-level node that is being removed. It is expected that garbage collection would take care of the whole subtree. You are not expected to traverse the child tree in it.
*/

export function removeChild(parentInstance, child) {
  child.destroy();
  child.off(EVENTS_NAMESPACE);
  updatePicture(parentInstance);
}

/**
 * This method should mutate the `textInstance` and update its text content to `nextText`.
 *
 * Here, `textInstance` is a node created by `createTextInstance`.
*/

/**
 * This method is only called if you returned `true` from `finalizeInitialChildren` for this instance.
 *
 * It lets you do some additional work after the node is actually attached to the tree on the screen for the first time. For example, the DOM renderer uses it to trigger focus on nodes with the `autoFocus` attribute.
 *
 * Note that `commitMount` does not mirror `removeChild` one to one because `removeChild` is only called for the top-level removed node. This is why ideally `commitMount` should not mutate any nodes other than the `instance` itself. For example, if it registers some events on some node above, it will be your responsibility to traverse the tree in `removeChild` and clean them up, which is not ideal.
 *
 * The `internalHandle` data structure is meant to be opaque. If you bend the rules and rely on its internal fields, be aware that it may change significantly between versions. You're taking on additional maintenance risk by reading from it, and giving up all guarantees if you write something to it.
 *
 * If you never return `true` from `finalizeInitialChildren`, you can leave it empty.
*/

/**
 * This method should mutate the `instance` according to the set of changes in `updatePayload`. Here, `updatePayload` is the object that you've returned from `prepareUpdate` and has an arbitrary structure that makes sense for your renderer. For example, the DOM renderer returns an update payload like `[prop1, value1, prop2, value2, ...]` from `prepareUpdate`, and that structure gets passed into `commitUpdate`. Ideally, all the diffing and calculation should happen inside `prepareUpdate` so that `commitUpdate` can be fast and straightforward.
 *
 * The `internalHandle` data structure is meant to be opaque. If you bend the rules and rely on its internal fields, be aware that it may change significantly between versions. You're taking on additional maintenance risk by reading from it, and giving up all guarantees if you write something to it.
*/

export function commitUpdate(
  instance,
  updatePayload,
  type,
  oldProps,
  newProps
) {
  // 比较新老属性，应用到instance上。
  applyNodeProps(instance, newProps, oldProps);
}