nrgy/chunk-KBQAMS64.cjs

The library for reactive programming using efficient computing and MVC/MVVM patterns

"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }


var _chunk25QOJNEUcjs = require('./chunk-25QOJNEU.cjs');

// src/mvc-react/NrgyControllerExtension.tsx




var _react = require('react'); var _react2 = _interopRequireDefault(_react);
var NrgyControllerExtensionContext = _react.createContext.call(void 0, []);
function useNrgyControllerExtensionContext() {
  return _react.useContext.call(void 0, NrgyControllerExtensionContext);
}
var NrgyControllerExtension = ({ children, provider }) => {
  const parentProviders = _react.useContext.call(void 0, NrgyControllerExtensionContext);
  const [nextProviders] = _react.useState.call(void 0, () => [...parentProviders, provider]);
  return /* @__PURE__ */ _react2.default.createElement(NrgyControllerExtensionContext.Provider, { value: nextProviders }, children);
};

// src/mvc-react/useController.ts

function useController(declaration, props) {
  var _a;
  const reactExtensionProviders = useNrgyControllerExtensionContext();
  const hookContextRef = _react.useRef.call(void 0, );
  if (((_a = hookContextRef.current) == null ? void 0 : _a.declaration) !== declaration) {
    const view = _chunk25QOJNEUcjs.createViewProxy.call(void 0, props != null ? props : {});
    const providers = [...reactExtensionProviders, _chunk25QOJNEUcjs.provideView.call(void 0, view)];
    const controller = new declaration(providers);
    hookContextRef.current = {
      declaration,
      controller,
      view
    };
  } else {
    for (const provider of reactExtensionProviders) {
      provider({});
    }
  }
  _react.useEffect.call(void 0, () => {
    const context = hookContextRef.current;
    if (context) {
      context.view.update(props);
    }
  }, [props]);
  _react.useEffect.call(void 0, () => {
    const context = hookContextRef.current;
    if (context) {
      context.view.mount();
    }
    return () => {
      if (context) {
        context.view.destroy();
        context.controller.destroy();
      }
      if (hookContextRef.current === context) {
        hookContextRef.current = void 0;
      }
    };
  }, [declaration]);
  return hookContextRef.current.controller;
}

// src/mvc-react/ViewControllerProvider.tsx


// src/core/internals/createWeakMap.ts
var LeakyMap = class {
  constructor() {
    this.map = /* @__PURE__ */ new Map();
  }
  get [Symbol.toStringTag]() {
    return "LeakyMap";
  }
  get(key) {
    return this.map.get(key);
  }
  has(key) {
    return this.map.has(key);
  }
  set(key, value) {
    this.map.set(key, value);
    return this;
  }
  delete(key) {
    return this.map.delete(key);
  }
};
var WeakMapImpl = "WeakMap" in globalThis && globalThis["WeakMap"] ? globalThis.WeakMap : LeakyMap;
function createWeakMap() {
  return new WeakMapImpl();
}

// src/mvc-react/ViewControllerProvider.tsx
var EMPTY_VALUE = Symbol("nrgy.EMPTY_VALUE");
var EMPTY_CONTEXT = _react.createContext.call(void 0, EMPTY_VALUE);
var REACT_CONTEXTS = createWeakMap();
function useProvidedViewController(declaration) {
  var _a;
  const reactContext = (_a = REACT_CONTEXTS.get(declaration)) != null ? _a : EMPTY_CONTEXT;
  const value = _react.useContext.call(void 0, reactContext);
  if (value === EMPTY_VALUE) {
    throw new Error("Controller is not provided");
  }
  return value;
}
function useOptionalViewController(declaration, defaultValue) {
  var _a;
  const reactContext = (_a = REACT_CONTEXTS.get(declaration)) != null ? _a : EMPTY_CONTEXT;
  const value = _react.useContext.call(void 0, reactContext);
  return value === EMPTY_VALUE ? defaultValue : value;
}
var ViewControllerProvider = (props) => {
  const { children, declaration, controller } = props;
  let ViewProviderContext = REACT_CONTEXTS.get(declaration);
  if (!ViewProviderContext) {
    ViewProviderContext = _react.createContext.call(void 0, EMPTY_VALUE);
    REACT_CONTEXTS.set(declaration, ViewProviderContext);
  }
  return /* @__PURE__ */ _react2.default.createElement(ViewProviderContext.Provider, { value: controller }, children);
};

// src/mvc-react/withViewController.tsx

function withViewController(controllerDeclaration) {
  return (ViewComponent) => {
    return function(props) {
      const controller = useController(controllerDeclaration, props);
      return /* @__PURE__ */ _react2.default.createElement(
        ViewControllerProvider,
        {
          declaration: controllerDeclaration,
          controller
        },
        /* @__PURE__ */ _react2.default.createElement(ViewComponent, { ...props, controller })
      );
    };
  };
}

// src/mvc-react/withViewModel.tsx

function withViewModel(viewModelDeclaration) {
  return (ViewComponent) => {
    return withViewModelImpl(viewModelDeclaration, ViewComponent);
  };
}
function withViewModelImpl(viewModelDeclaration, ViewComponent) {
  const HOC = (props) => {
    const { children, ...restProps } = props;
    const viewModel = useController(
      viewModelDeclaration,
      restProps
    );
    return /* @__PURE__ */ _react2.default.createElement(
      ViewControllerProvider,
      {
        declaration: viewModelDeclaration,
        controller: viewModel
      },
      /* @__PURE__ */ _react2.default.createElement(
        ViewComponent,
        {
          ...restProps,
          viewModel,
          children
        }
      )
    );
  };
  return HOC;
}









exports.NrgyControllerExtension = NrgyControllerExtension; exports.useController = useController; exports.useProvidedViewController = useProvidedViewController; exports.useOptionalViewController = useOptionalViewController; exports.ViewControllerProvider = ViewControllerProvider; exports.withViewController = withViewController; exports.withViewModel = withViewModel;