nrgy/chunk-N5WIGA5Z.js

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

import {
  createViewProxy,
  provideView
} from "./chunk-WLVNLWGT.js";

// src/mvc-react/NrgyControllerExtension.tsx
import React, {
  createContext,
  useContext,
  useState
} from "react";
var NrgyControllerExtensionContext = createContext([]);
function useNrgyControllerExtensionContext() {
  return useContext(NrgyControllerExtensionContext);
}
var NrgyControllerExtension = ({ children, provider }) => {
  const parentProviders = useContext(NrgyControllerExtensionContext);
  const [nextProviders] = useState(() => [...parentProviders, provider]);
  return /* @__PURE__ */ React.createElement(NrgyControllerExtensionContext.Provider, { value: nextProviders }, children);
};

// src/mvc-react/useController.ts
import { useEffect, useRef } from "react";
function useController(declaration, props) {
  var _a;
  const reactExtensionProviders = useNrgyControllerExtensionContext();
  const hookContextRef = useRef();
  if (((_a = hookContextRef.current) == null ? void 0 : _a.declaration) !== declaration) {
    const view = createViewProxy(props != null ? props : {});
    const providers = [...reactExtensionProviders, provideView(view)];
    const controller = new declaration(providers);
    hookContextRef.current = {
      declaration,
      controller,
      view
    };
  } else {
    for (const provider of reactExtensionProviders) {
      provider({});
    }
  }
  useEffect(() => {
    const context = hookContextRef.current;
    if (context) {
      context.view.update(props);
    }
  }, [props]);
  useEffect(() => {
    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
import React2, { createContext as createContext2, useContext as useContext2 } from "react";

// 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 = createContext2(EMPTY_VALUE);
var REACT_CONTEXTS = createWeakMap();
function useProvidedViewController(declaration) {
  var _a;
  const reactContext = (_a = REACT_CONTEXTS.get(declaration)) != null ? _a : EMPTY_CONTEXT;
  const value = useContext2(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 = useContext2(reactContext);
  return value === EMPTY_VALUE ? defaultValue : value;
}
var ViewControllerProvider = (props) => {
  const { children, declaration, controller } = props;
  let ViewProviderContext = REACT_CONTEXTS.get(declaration);
  if (!ViewProviderContext) {
    ViewProviderContext = createContext2(EMPTY_VALUE);
    REACT_CONTEXTS.set(declaration, ViewProviderContext);
  }
  return /* @__PURE__ */ React2.createElement(ViewProviderContext.Provider, { value: controller }, children);
};

// src/mvc-react/withViewController.tsx
import React3 from "react";
function withViewController(controllerDeclaration) {
  return (ViewComponent) => {
    return function(props) {
      const controller = useController(controllerDeclaration, props);
      return /* @__PURE__ */ React3.createElement(
        ViewControllerProvider,
        {
          declaration: controllerDeclaration,
          controller
        },
        /* @__PURE__ */ React3.createElement(ViewComponent, { ...props, controller })
      );
    };
  };
}

// src/mvc-react/withViewModel.tsx
import React4 from "react";
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__ */ React4.createElement(
      ViewControllerProvider,
      {
        declaration: viewModelDeclaration,
        controller: viewModel
      },
      /* @__PURE__ */ React4.createElement(
        ViewComponent,
        {
          ...restProps,
          viewModel,
          children
        }
      )
    );
  };
  return HOC;
}

export {
  NrgyControllerExtension,
  useController,
  useProvidedViewController,
  useOptionalViewController,
  ViewControllerProvider,
  withViewController,
  withViewModel
};