@startlibs/core 1.0.7 → 1.2.0-rc.1

package/lib-yak/hooks/willUseLayers.mjs

@@ -0,0 +1,55 @@
+import React, { useCallback, useState } from 'react';
+import { callIfFunction } from '@startlibs/utils';
+import _slicedToArray from '@babel/runtime/helpers/slicedToArray';
+import { willUseSharedCallback } from './willUseSharedCallback.mjs';
+
+const willUseLayers = function () {
+  let useEffect = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : React.useEffect;
+  const _willUseSharedCallbac = willUseSharedCallback(useEffect),
+    _willUseSharedCallbac2 = _slicedToArray(_willUseSharedCallbac, 3),
+    useRegisterSharedCallback = _willUseSharedCallbac2[0],
+    callGroup = _willUseSharedCallbac2[1],
+    getSize = _willUseSharedCallbac2[2];
+  const useLayer = function () {
+    let _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+      onFirst = _ref.onFirst,
+      onEmpty = _ref.onEmpty,
+      onTop = _ref.onTop,
+      onRemove = _ref.onRemove;
+    let listener = arguments.length > 1 ? arguments[1] : undefined;
+    const resetIndex = useCallback(() => {
+      setIndex(getIndex());
+      if (getIndex() + 1 === getSize()) {
+        callIfFunction(onTop, getIndex);
+      }
+    }, []);
+    const getIndex = useRegisterSharedCallback(resetIndex, listener);
+    const _useState = useState(getIndex()),
+      _useState2 = _slicedToArray(_useState, 2),
+      index = _useState2[0],
+      setIndex = _useState2[1];
+    useEffect(() => {
+      if (getIndex() === 0) {
+        callIfFunction(onFirst);
+      }
+      resetIndex();
+      return () => {
+        callIfFunction(onRemove, getSize());
+        if (getSize() === 0) {
+          callIfFunction(onEmpty);
+        }
+        callGroup();
+      };
+    }, []);
+    return [index, {
+      isFirst: () => getIndex() === 1,
+      isTop: () => getIndex() === getSize() - 1,
+      isEmpty: () => getSize() === 0,
+      getSize: () => getSize()
+    }];
+  };
+  return [useLayer, getSize];
+};
+
+export { willUseLayers };
+//# sourceMappingURL=willUseLayers.mjs.map

package/lib-yak/hooks/willUseLayers.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"willUseLayers.mjs","sources":["../../src/hooks/willUseLayers.jsx"],"sourcesContent":["import React, {useState, useCallback} from 'react'\nimport {willUseSharedCallback} from './willUseSharedCallback'\nimport {callIfFunction} from '@startlibs/utils'\n\n\nexport const willUseLayers = (useEffect = React.useEffect) => {\n  const [useRegisterSharedCallback,callGroup,getSize] = willUseSharedCallback(useEffect)\n  const useLayer = ({onFirst, onEmpty, onTop, onRemove} = {}, listener) => {\n\n    const resetIndex = useCallback(() => {\n      setIndex(getIndex())\n      if (getIndex()+1 === getSize()) {\n        callIfFunction(onTop,getIndex)\n      }\n    },[])\n\n    const getIndex = useRegisterSharedCallback(resetIndex, listener)\n    const [index,setIndex] = useState(getIndex())\n\n    useEffect(() => {\n      if (getIndex() === 0) {\n        callIfFunction(onFirst)\n      }\n      resetIndex()\n      return () => {\n        callIfFunction(onRemove,getSize())\n        if (getSize() === 0) {\n          callIfFunction(onEmpty)\n        }\n        callGroup()\n      }\n    },[])\n\n    return [index,{\n      isFirst: ()=> getIndex() === 1,\n      isTop: () => getIndex() === getSize()-1,\n      isEmpty: () => getSize() === 0,\n      getSize: () => getSize()\n    }]\n  }\n  return [useLayer,getSize]\n}"],"names":["willUseLayers","useEffect","arguments","length","undefined","React","_willUseSharedCallbac","willUseSharedCallback","_willUseSharedCallbac2","_slicedToArray","useRegisterSharedCallback","callGroup","getSize","useLayer","_ref","onFirst","onEmpty","onTop","onRemove","listener","resetIndex","useCallback","setIndex","getIndex","callIfFunction","_useState","useState","_useState2","index","isFirst","isTop","isEmpty"],"mappings":";;;;;MAKaA,aAAa,GAAG,YAAiC;EAAA,IAAhCC,SAAS,GAAAC,SAAA,CAAAC,MAAA,QAAAD,SAAA,QAAAE,SAAA,GAAAF,SAAA,MAAGG,KAAK,CAACJ,SAAS;EACvD,MAAAK,qBAAA,GAAsDC,qBAAqB,CAACN,SAAS,CAAC;IAAAO,sBAAA,GAAAC,cAAA,CAAAH,qBAAA;IAA/EI,yBAAyB,GAAAF,sBAAA;IAACG,SAAS,GAAAH,sBAAA;IAACI,OAAO,GAAAJ,sBAAA;EAClD,MAAMK,QAAQ,GAAG,YAAwD;IAAA,IAAAC,IAAA,GAAAZ,SAAA,CAAAC,MAAA,QAAAD,SAAA,QAAAE,SAAA,GAAAF,SAAA,MAAjB,EAAE;MAAvCa,OAAO,GAAAD,IAAA,CAAPC,OAAO;MAAEC,OAAO,GAAAF,IAAA,CAAPE,OAAO;MAAEC,KAAK,GAAAH,IAAA,CAALG,KAAK;MAAEC,QAAQ,GAAAJ,IAAA,CAARI,QAAQ;IAAA,IAAQC,QAAQ,GAAAjB,SAAA,CAAAC,MAAA,OAAAD,SAAA,MAAAE,SAAA;IAElE,MAAMgB,UAAU,GAAGC,WAAW,CAAC,MAAM;MACnCC,QAAQ,CAACC,QAAQ,EAAE,CAAC;MACpB,IAAIA,QAAQ,EAAE,GAAC,CAAC,KAAKX,OAAO,EAAE,EAAE;QAC9BY,cAAc,CAACP,KAAK,EAACM,QAAQ,CAAC;;KAEjC,EAAC,EAAE,CAAC;IAEL,MAAMA,QAAQ,GAAGb,yBAAyB,CAACU,UAAU,EAAED,QAAQ,CAAC;IAChE,MAAAM,SAAA,GAAyBC,QAAQ,CAACH,QAAQ,EAAE,CAAC;MAAAI,UAAA,GAAAlB,cAAA,CAAAgB,SAAA;MAAtCG,KAAK,GAAAD,UAAA;MAACL,QAAQ,GAAAK,UAAA;IAErB1B,SAAS,CAAC,MAAM;MACd,IAAIsB,QAAQ,EAAE,KAAK,CAAC,EAAE;QACpBC,cAAc,CAACT,OAAO,CAAC;;MAEzBK,UAAU,EAAE;MACZ,OAAO,MAAM;QACXI,cAAc,CAACN,QAAQ,EAACN,OAAO,EAAE,CAAC;QAClC,IAAIA,OAAO,EAAE,KAAK,CAAC,EAAE;UACnBY,cAAc,CAACR,OAAO,CAAC;;QAEzBL,SAAS,EAAE;OACZ;KACF,EAAC,EAAE,CAAC;IAEL,OAAO,CAACiB,KAAK,EAAC;MACZC,OAAO,EAAEA,MAAKN,QAAQ,EAAE,KAAK,CAAC;MAC9BO,KAAK,EAAEA,MAAMP,QAAQ,EAAE,KAAKX,OAAO,EAAE,GAAC,CAAC;MACvCmB,OAAO,EAAEA,MAAMnB,OAAO,EAAE,KAAK,CAAC;MAC9BA,OAAO,EAAEA,MAAMA,OAAO;KACvB,CAAC;GACH;EACD,OAAO,CAACC,QAAQ,EAACD,OAAO,CAAC;AAC3B;;;;"}

package/lib-yak/hooks/willUseSharedCallback.mjs

@@ -0,0 +1,70 @@
+import React, { useRef } from 'react';
+
+const callList = function (list, firstArg) {
+  for (var _len = arguments.length, args = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
+    args[_key - 2] = arguments[_key];
+  }
+  return list.map(_ref => {
+    let current = _ref.current;
+    return typeof firstArg === 'function' ? firstArg(current) : current(firstArg, ...args);
+  });
+};
+const willUseSharedCallback = function () {
+  let useEffect = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : React.useEffect;
+  let mountedCallbacks = [];
+  let listenerCallbacks = [];
+  const remove = ref => mountedCallbacks = mountedCallbacks.filter(_ => _ !== ref);
+  const add = ref => mountedCallbacks = mountedCallbacks.concat([ref]);
+  const get = () => mountedCallbacks;
+  const removeListener = ref => listenerCallbacks = listenerCallbacks.filter(_ => _ !== ref);
+  const addListener = ref => listenerCallbacks = listenerCallbacks.concat([ref]);
+  const getListeners = ref => listenerCallbacks;
+  const lastCall = {
+    current: null,
+    index: 0
+  };
+  const call = function () {
+    for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+      args[_key2] = arguments[_key2];
+    }
+    const resp = callList(get(), ...args);
+    callList(getListeners(), ...args);
+    lastCall.current = args;
+    lastCall.index++;
+    return resp;
+  };
+  const getSize = () => get().length;
+  const useRegister = function (callback) {
+    let listener = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+    const ref = useRef(callback);
+    if (ref.current !== callback) {
+      ref.current = callback;
+    }
+    const lastCallIndex = lastCall.index;
+    useEffect(() => {
+      if (!ref.current) {
+        return;
+      }
+      if (listener) {
+        addListener(ref);
+      } else {
+        add(ref);
+        if (lastCallIndex !== lastCall.index && lastCall.current) {
+          callList([ref], ...lastCall.current);
+        }
+      }
+      return () => {
+        if (listener) {
+          removeListener(ref);
+        } else {
+          remove(ref);
+        }
+      };
+    }, []);
+    return () => get().indexOf(ref);
+  };
+  return [useRegister, call, getSize];
+};
+
+export { willUseSharedCallback };
+//# sourceMappingURL=willUseSharedCallback.mjs.map

package/lib-yak/hooks/willUseSharedCallback.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"willUseSharedCallback.mjs","sources":["../../src/hooks/willUseSharedCallback.jsx"],"sourcesContent":["import React, {useRef} from 'react'\n\n\nconst callList = (list, firstArg, ...args) => list.map(({current}) => typeof firstArg === 'function' ? firstArg(current) : current(firstArg,...args))\n\nexport const willUseSharedCallback = (useEffect = React.useEffect) => {\n  let mountedCallbacks = []\n  let listenerCallbacks = []\n  const remove = (ref) => mountedCallbacks = mountedCallbacks.filter(_ => _ !== ref)\n  const add = (ref) => mountedCallbacks = mountedCallbacks.concat([ref])\n  const get = () => mountedCallbacks\n\n  const removeListener = (ref) => listenerCallbacks = listenerCallbacks.filter(_ => _ !== ref)\n  const addListener = (ref) => listenerCallbacks = listenerCallbacks.concat([ref])\n  const getListeners = (ref) => listenerCallbacks\n\n  const lastCall = {current:null,index:0}\n\n  const call = (...args) => {\n    const resp = callList(get(), ...args)\n    callList(getListeners(), ...args)\n    lastCall.current = args\n    lastCall.index++\n    return resp\n  }\n  const getSize = () => get().length\n\n  const useRegister = (callback, listener = false) => {\n    const ref = useRef(callback)\n    if (ref.current !== callback) {\n      ref.current = callback\n    }\n    const lastCallIndex = lastCall.index\n    useEffect(() => {\n      if (!ref.current) { return }\n      if (listener) {\n        addListener(ref)\n      } else {\n        add(ref)\n        if (lastCallIndex !== lastCall.index && lastCall.current) {\n          callList([ref],...lastCall.current)\n        }\n      }\n      return () => {\n        if (listener) {\n          removeListener(ref)\n        } else {\n          remove(ref)\n        }\n      }\n    }, [])\n    return () => get().indexOf(ref)\n  }\n\n  return [\n    useRegister,\n    call,\n    getSize\n  ]\n}"],"names":["callList","list","firstArg","_len","arguments","length","args","Array","_key","map","_ref","current","willUseSharedCallback","useEffect","undefined","React","mountedCallbacks","listenerCallbacks","remove","ref","filter","_","add","concat","get","removeListener","addListener","getListeners","lastCall","index","call","_len2","_key2","resp","getSize","useRegister","callback","listener","useRef","lastCallIndex","indexOf"],"mappings":"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"}

package/lib-yak/hooks/willUseSharedState.mjs

@@ -0,0 +1,41 @@
+import { useState } from 'react';
+import { ifUndefined, callIfFunction } from '@startlibs/utils';
+import _slicedToArray from '@babel/runtime/helpers/slicedToArray';
+import { willUseSharedCallback } from './willUseSharedCallback.mjs';
+
+const notDefined = {};
+const willUseSharedState = initialValue => {
+  const _willUseSharedCallbac = willUseSharedCallback(),
+    _willUseSharedCallbac2 = _slicedToArray(_willUseSharedCallbac, 3),
+    useRegisterGroupCallback = _willUseSharedCallbac2[0],
+    callGroup = _willUseSharedCallbac2[1],
+    getSize = _willUseSharedCallbac2[2];
+  let sharedValue = ifUndefined(initialValue, notDefined);
+  const setGroupState = newValue => {
+    sharedValue = callIfFunction(newValue, sharedValue);
+    callGroup(sharedValue);
+  };
+  const refState = () => {
+    useRegisterGroupCallback();
+    return [() => sharedValue, setGroupState];
+  };
+  const valueState = defaultValue => {
+    const prevValue = sharedValue !== notDefined ? sharedValue : defaultValue;
+    if (prevValue === defaultValue) {
+      sharedValue = defaultValue;
+    }
+    const _useState = useState(prevValue),
+      _useState2 = _slicedToArray(_useState, 2),
+      value = _useState2[0],
+      setValue = _useState2[1];
+    useRegisterGroupCallback(setValue);
+    return [value, setGroupState];
+  };
+  const clear = () => {
+    sharedValue = notDefined;
+  };
+  return [valueState, refState, setGroupState, () => sharedValue, clear];
+};
+
+export { willUseSharedState };
+//# sourceMappingURL=willUseSharedState.mjs.map

package/lib-yak/hooks/willUseSharedState.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"willUseSharedState.mjs","sources":["../../src/hooks/willUseSharedState.jsx"],"sourcesContent":["import React, {useState} from 'react'\nimport {callIfFunction, ifUndefined} from '@startlibs/utils'\nimport {willUseSharedCallback} from './willUseSharedCallback'\n\nconst notDefined = {}\n\nexport const willUseSharedState = (initialValue) => {\n  const [useRegisterGroupCallback,callGroup,getSize] = willUseSharedCallback()\n  let sharedValue = ifUndefined(initialValue,notDefined)\n\n  const setGroupState = (newValue) => {\n    sharedValue = callIfFunction(newValue,sharedValue)\n    callGroup(sharedValue)\n  }\n\n  const refState = () => {\n    useRegisterGroupCallback()\n    return [()=>sharedValue,setGroupState]\n  }\n\n  const valueState = (defaultValue) => {\n    const prevValue = sharedValue !== notDefined ? sharedValue : defaultValue\n    if (prevValue === defaultValue) {\n      sharedValue = defaultValue\n    }\n    const [value, setValue] = useState(prevValue)\n    useRegisterGroupCallback(setValue)\n    return [value,setGroupState]\n  }\n  const clear = () => {\n    sharedValue = notDefined\n  }\n  return [valueState,refState,setGroupState,()=>sharedValue,clear]\n}"],"names":["notDefined","willUseSharedState","initialValue","_willUseSharedCallbac","willUseSharedCallback","_willUseSharedCallbac2","_slicedToArray","useRegisterGroupCallback","callGroup","getSize","sharedValue","ifUndefined","setGroupState","newValue","callIfFunction","refState","valueState","defaultValue","prevValue","_useState","useState","_useState2","value","setValue","clear"],"mappings":";;;;;AAIA,MAAMA,UAAU,GAAG,EAAE;MAERC,kBAAkB,GAAIC,YAAY,IAAK;EAClD,MAAAC,qBAAA,GAAqDC,qBAAqB,EAAE;IAAAC,sBAAA,GAAAC,cAAA,CAAAH,qBAAA;IAArEI,wBAAwB,GAAAF,sBAAA;IAACG,SAAS,GAAAH,sBAAA;IAACI,OAAO,GAAAJ,sBAAA;EACjD,IAAIK,WAAW,GAAGC,WAAW,CAACT,YAAY,EAACF,UAAU,CAAC;EAEtD,MAAMY,aAAa,GAAIC,QAAQ,IAAK;IAClCH,WAAW,GAAGI,cAAc,CAACD,QAAQ,EAACH,WAAW,CAAC;IAClDF,SAAS,CAACE,WAAW,CAAC;GACvB;EAED,MAAMK,QAAQ,GAAGA,MAAM;IACrBR,wBAAwB,EAAE;IAC1B,OAAO,CAAC,MAAIG,WAAW,EAACE,aAAa,CAAC;GACvC;EAED,MAAMI,UAAU,GAAIC,YAAY,IAAK;IACnC,MAAMC,SAAS,GAAGR,WAAW,KAAKV,UAAU,GAAGU,WAAW,GAAGO,YAAY;IACzE,IAAIC,SAAS,KAAKD,YAAY,EAAE;MAC9BP,WAAW,GAAGO,YAAY;;IAE5B,MAAAE,SAAA,GAA0BC,QAAQ,CAACF,SAAS,CAAC;MAAAG,UAAA,GAAAf,cAAA,CAAAa,SAAA;MAAtCG,KAAK,GAAAD,UAAA;MAAEE,QAAQ,GAAAF,UAAA;IACtBd,wBAAwB,CAACgB,QAAQ,CAAC;IAClC,OAAO,CAACD,KAAK,EAACV,aAAa,CAAC;GAC7B;EACD,MAAMY,KAAK,GAAGA,MAAM;IAClBd,WAAW,GAAGV,UAAU;GACzB;EACD,OAAO,CAACgB,UAAU,EAACD,QAAQ,EAACH,aAAa,EAAC,MAAIF,WAAW,EAACc,KAAK,CAAC;AAClE;;;;"}

package/lib-yak/hooks/willUseSpreadState.mjs

@@ -0,0 +1,119 @@
+import React, { useEffect, useMemo, useContext, useState, useCallback } from 'react';
+import { formatPath, _s } from '@startlibs/utils';
+import _slicedToArray from '@babel/runtime/helpers/slicedToArray';
+import _set from 'lodash/fp/set';
+import _update from 'lodash/fp/update';
+import { useIsUnmounted } from './useIsUnmounted.mjs';
+import { useRefState } from './useRefState.mjs';
+import _isFunction from 'lodash/fp/isFunction';
+import _get from 'lodash/fp/get';
+import _isArray from 'lodash/fp/isArray';
+import _isString from 'lodash/fp/isString';
+import { useConsumerCatalog, useCatalogManager } from './useConsumerCatalog.mjs';
+
+const updateAllInputsState = (inputs, values) => {
+  const deferedUndefined = [];
+  inputs.forEach(input => {
+    const _input = _slicedToArray(input, 2),
+      setValue = _input[0],
+      selector = _input[1];
+    const newValue = selector(values);
+    if (newValue === undefined) {
+      deferedUndefined.push([setValue, newValue]);
+    } else {
+      setValue(newValue);
+    }
+  });
+  deferedUndefined.forEach(_ref => {
+    let _ref2 = _slicedToArray(_ref, 2),
+      set = _ref2[0],
+      value = _ref2[1];
+    return set(value);
+  });
+};
+const pathSelector = path => _s.get(path || []);
+const parsePathOrSelector = pathOrSelector => {
+  const isNotSelector = typeof pathOrSelector !== 'function';
+  if (isNotSelector) {
+    return [formatPath(pathOrSelector), pathSelector(pathOrSelector)];
+  } else {
+    return ['', pathOrSelector];
+  }
+};
+const willUseSpreadState = function (defaultContextValue) {
+  let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  const Context = /*#__PURE__*/React.createContext(defaultContextValue);
+  const EMPTY_GLOBAL = {};
+  let prevInitState = EMPTY_GLOBAL;
+  let globalState = EMPTY_GLOBAL;
+  const getGlobalState = key => _isString(key) || _isArray(key) ? _get(key, globalState) : globalState;
+  const useProvideSpreadState = (initState, setCallback) => {
+    const _useConsumerCatalog = useConsumerCatalog(input => updateAllInputsState([input], state.get())),
+      _useConsumerCatalog2 = _slicedToArray(_useConsumerCatalog, 2),
+      consumerList = _useConsumerCatalog2[0],
+      manager = _useConsumerCatalog2[1];
+    const state = useRefState(initState, setCallback);
+    if (options.initRefCheck) {
+      if (prevInitState !== initState) {
+        globalState = initState;
+      }
+      prevInitState = initState;
+    }
+    if (globalState === EMPTY_GLOBAL) {
+      globalState = initState;
+    }
+    useEffect(() => {
+      globalState = state.get();
+    }, []);
+    const setState = (newState, fastPath, config) => {
+      // console.log("Fastpath noop:"+fastPath)
+      state.set(newState, config);
+      globalState = state.get();
+      updateAllInputsState(consumerList(), state.get());
+    };
+    const contextValue = useMemo(() => [state.get, setState, manager], []);
+    return [Context.Provider, contextValue, [state.get, setState]];
+  };
+  const useSpreadState = (pathOrSelector, inputs) => {
+    const _useContext = useContext(Context),
+      _useContext2 = _slicedToArray(_useContext, 3),
+      getSpreadState = _useContext2[0],
+      setSpreadState = _useContext2[1],
+      manager = _useContext2[2];
+    const _parsePathOrSelector = parsePathOrSelector(pathOrSelector),
+      _parsePathOrSelector2 = _slicedToArray(_parsePathOrSelector, 2),
+      path = _parsePathOrSelector2[0],
+      selector = _parsePathOrSelector2[1];
+    const pathOrInput = [path] || inputs || [];
+    const _useState = useState(selector(getSpreadState())),
+      _useState2 = _slicedToArray(_useState, 2),
+      value = _useState2[0],
+      setValue = _useState2[1];
+    const isUnmounted = useIsUnmounted();
+    const currentPath = useRefState(path);
+    if (path !== currentPath.get()) {
+      /* when path changes, the consumerCatalogCallback will update the new value
+      *  another solution would be to call setValue here directly
+      *  the return value will still be the old, but will be changed before render, just like getDerivedStateFromProps
+      *
+      *  if there's a need for the return value to be the same, the value or, if enters here new value,
+      *  can be returned in an temp variable
+      * */
+      currentPath.set(path);
+    }
+    const input = useMemo(() => [v => {
+      /* noop for elements that may be unregistered while looping through consumerList */
+      if (path === currentPath.get() && !isUnmounted()) {
+        setValue(v);
+      }
+    }, selector], pathOrInput);
+    useCatalogManager(manager, input);
+    const setState = useCallback(v => setSpreadState((_isFunction(v) ? pathOrSelector === undefined ? () => v : _update : _set)(path, v), path), pathOrInput);
+    const getValue = () => selector(getGlobalState());
+    return [value, setState, getValue];
+  };
+  return [useProvideSpreadState, useSpreadState, Context, getGlobalState];
+};
+
+export { willUseSpreadState };
+//# sourceMappingURL=willUseSpreadState.mjs.map

package/lib-yak/hooks/willUseSpreadState.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"willUseSpreadState.mjs","sources":["../../src/hooks/willUseSpreadState.jsx"],"sourcesContent":["import React, {useCallback, useContext, useEffect, useMemo, useState} from 'react'\nimport {_s, formatPath} from '@startlibs/utils'\nimport _ from 'lodash/fp'\nimport {useCatalogManager, useConsumerCatalog} from './useConsumerCatalog'\nimport {useIsUnmounted} from './useIsUnmounted'\nimport {useRefState} from './useRefState'\n\nconst updateAllInputsState = (inputs, values) => {\n  const deferedUndefined = []\n  inputs.forEach((input) => {\n    const [setValue, selector] = input\n    const newValue = selector(values)\n    if (newValue === undefined) {\n      deferedUndefined.push([setValue,newValue])\n    } else {\n      setValue(newValue)\n    }\n  })\n  deferedUndefined.forEach(([set,value])=> set(value))\n}\n\nconst pathSelector = (path) => _s.get(path || [])\nconst parsePathOrSelector = (pathOrSelector) => {\n  const isNotSelector = typeof pathOrSelector !== 'function'\n  if (isNotSelector) {\n    return [formatPath(pathOrSelector), pathSelector(pathOrSelector)]\n  } else {\n    return ['', pathOrSelector]\n  }\n}\nexport const willUseSpreadState = (defaultContextValue,options = {}) => {\n\n  const Context = React.createContext(defaultContextValue)\n  const EMPTY_GLOBAL = {}\n  let prevInitState = EMPTY_GLOBAL\n  let globalState = EMPTY_GLOBAL\n  const getGlobalState = (key) => _.isString(key) || _.isArray(key) ? _.get(key,globalState) : globalState\n\n  const useProvideSpreadState = (initState, setCallback) => {\n    const [consumerList, manager] = useConsumerCatalog((input) => updateAllInputsState([input], state.get()))\n    const state = useRefState(initState, setCallback)\n\n    if (options.initRefCheck) {\n      if (prevInitState !== initState) {\n        globalState = initState\n      }\n      prevInitState = initState\n    }\n\n    if (globalState === EMPTY_GLOBAL) {\n      globalState = initState\n    }\n    useEffect(() => {\n      globalState = state.get()\n    },[])\n\n    const setState = (newState, fastPath, config) => {\n      // console.log(\"Fastpath noop:\"+fastPath)\n      state.set(newState, config)\n      globalState = state.get()\n      updateAllInputsState(consumerList(), state.get())\n    }\n    const contextValue = useMemo(() => [state.get, setState, manager], [])\n\n    return [Context.Provider, contextValue, [state.get, setState]]\n  }\n\n  const useSpreadState = (pathOrSelector, inputs) => {\n    const [getSpreadState, setSpreadState, manager] = useContext(Context)\n    const [path, selector] = parsePathOrSelector(pathOrSelector)\n    const pathOrInput = [path] || inputs || []\n    const [value, setValue] = useState(selector(getSpreadState()))\n\n    const isUnmounted = useIsUnmounted()\n\n    const currentPath = useRefState(path)\n    if (path !== currentPath.get()) {\n      /* when path changes, the consumerCatalogCallback will update the new value\n      *  another solution would be to call setValue here directly\n      *  the return value will still be the old, but will be changed before render, just like getDerivedStateFromProps\n      *\n      *  if there's a need for the return value to be the same, the value or, if enters here new value,\n      *  can be returned in an temp variable\n      * */\n      currentPath.set(path)\n    }\n\n    const input = useMemo(() => [(v) => {\n      /* noop for elements that may be unregistered while looping through consumerList */\n      if (path === currentPath.get() && !isUnmounted()) {\n        setValue(v)\n      }\n    }, selector], pathOrInput)\n\n    useCatalogManager(manager, input)\n    const setState = useCallback((v) => setSpreadState((_.isFunction(v) ? (pathOrSelector === undefined ? () => v : _.update) : _.set)(path, v), path), pathOrInput)\n    const getValue = () => selector(getGlobalState())\n    return [value, setState, getValue]\n  }\n\n\n  return [useProvideSpreadState, useSpreadState, Context, getGlobalState]\n}"],"names":["updateAllInputsState","inputs","values","deferedUndefined","forEach","input","_input","_slicedToArray","setValue","selector","newValue","undefined","push","_ref","_ref2","set","value","pathSelector","path","_s","get","parsePathOrSelector","pathOrSelector","isNotSelector","formatPath","willUseSpreadState","defaultContextValue","options","arguments","length","Context","React","createContext","EMPTY_GLOBAL","prevInitState","globalState","getGlobalState","key","_isString","_isArray","_get","useProvideSpreadState","initState","setCallback","_useConsumerCatalog","useConsumerCatalog","state","_useConsumerCatalog2","consumerList","manager","useRefState","initRefCheck","useEffect","setState","newState","fastPath","config","contextValue","useMemo","Provider","useSpreadState","_useContext","useContext","_useContext2","getSpreadState","setSpreadState","_parsePathOrSelector","_parsePathOrSelector2","pathOrInput","_useState","useState","_useState2","isUnmounted","useIsUnmounted","currentPath","v","useCatalogManager","useCallback","_isFunction","_update","_set","getValue"],"mappings":"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"}

package/lib-yak/index.mjs

@@ -0,0 +1,33 @@
+export { useConstant, useLazyConstant } from './hooks/useConstant.mjs';
+export { willUseSharedCallback } from './hooks/willUseSharedCallback.mjs';
+export { willUseSharedState } from './hooks/willUseSharedState.mjs';
+export { Fill, Slot, SlotContext, SlotProvider, useFill, useHiddenFill } from './SlotFill.mjs';
+export { useCallState } from './hooks/useCallState.mjs';
+export { useIsUnmounted } from './hooks/useIsUnmounted.mjs';
+export { useRefState } from './hooks/useRefState.mjs';
+export { useRefToggle, useToggle } from './hooks/useToggle.mjs';
+export { clearPopups, usePopupToggle } from './hooks/usePopupToggle.mjs';
+export { PopupContext, StartlibsConsumer, StartlibsContext, StartlibsMetacontext, StartlibsProvider } from './StartlibsProvider.mjs';
+export { willUseLayers } from './hooks/willUseLayers.mjs';
+export { useCatalogManager, useConsumerCatalog } from './hooks/useConsumerCatalog.mjs';
+export { willUseSpreadState } from './hooks/willUseSpreadState.mjs';
+export { consumes } from './hocs/consumes.mjs';
+export { withDialogError } from './hocs/withDialogError.mjs';
+export { GroupEventFactory, withGroupEvent } from './hocs/withGroupEvent.mjs';
+export { WithRef } from './hocs/WithRef.mjs';
+export { WithLazyPlaceholder, WithLazyResource } from './hocs/WithLazyResource.mjs';
+export { useCallbackStable } from './hooks/useCallbackStable.mjs';
+export { WithEffect } from './hooks/WithEffect.mjs';
+export { useTitle } from './hooks/useTitle.mjs';
+export { useRecycleFocus } from './hooks/useRecycleFocus.mjs';
+export { usePrevious, usePreviousForEffect, usePreviousUnique } from './hooks/usePrevious.mjs';
+export { useEnsureRef } from './hooks/useEnsureRef.mjs';
+export { useForceUpdate, willUseForceUpdate } from './hooks/useForceUpdate.mjs';
+export { useUpdateOnResize } from './hooks/useUpdateOnResize.mjs';
+export { useAsyncEffect } from './hooks/useAsyncEffect.mjs';
+export { useUpdateEffect } from './hooks/useUpdateEffect.mjs';
+export { useRefMemo } from './hooks/useRefMemo.mjs';
+export { createLazyStatefulContext, createSelectableContext, createSelfStatefulContext, createStatefulContext, createTriggerUpdateContext, useUpdateSignal } from './hooks/useSignal.mjs';
+export { WithConstant } from './hooks/WithConstant.mjs';
+export { useWithTransition } from './hooks/useWithTransition.mjs';
+//# sourceMappingURL=index.mjs.map

package/lib-yak/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/package.json

@@ -1,49 +1,57 @@
 {
   "name": "@startlibs/core",
-  "version": "1.0.7",
+  "version": "1.2.0-rc.1",
   "description": "Startlibs Core",
-  "main": "lib/index.js",
+  "main": "lib/index.cjs",
+  "exports": {
+    ".": {
+      "source": "./src/index.js",
+      "yak": "./lib-yak/index.mjs",
+      "require": "./lib/index.cjs",
+      "import": "./lib/index.mjs",
+      "default": "./lib/index.mjs"
+    },
+    "./package.json": "./package.json",
+    "./*": {
+      "yak": "./lib-yak/*.mjs",
+      "import": "./lib/*.mjs"
+    }
+  },
   "sideEffects": false,
-  "source": true,
+  "source": "./src/index.js",
   "peerDependencies": {
     "@startlibs/utils": "*",
-    "lodash": "*",
-    "react": "*",
-    "react-dom": "*",
-    "styled-components": "*"
+    "@yak/react": "10.0.0",
+    "lodash": "^4.17.21",
+    "react": ">=16.8",
+    "react-dom": ">=16.8",
+    "styled-components": ">=5"
+  },
+  "peerDependenciesMeta": {
+    "@yak/react": {
+      "optional": true
+    }
   },
   "devDependencies": {
-    "@babel/core": "^7.2.0",
-    "@babel/plugin-external-helpers": "^7.2.0",
-    "@babel/plugin-proposal-class-properties": "^7.2.1",
-    "@babel/plugin-proposal-export-namespace-from": "^7.2.0",
-    "@babel/plugin-proposal-json-strings": "^7.2.0",
-    "@babel/plugin-proposal-logical-assignment-operators": "^7.20.7",
-    "@babel/plugin-proposal-nullish-coalescing-operator": "^7.18.6",
-    "@babel/plugin-proposal-object-rest-spread": "^7.2.0",
-    "@babel/plugin-proposal-optional-chaining": "^7.12.0",
-    "@babel/plugin-proposal-throw-expressions": "^7.2.0",
-    "@babel/plugin-syntax-dynamic-import": "^7.2.0",
-    "@babel/plugin-syntax-import-meta": "^7.2.0",
-    "@babel/plugin-transform-runtime": "^7.2.0",
-    "@babel/plugin-transform-spread": "^7.2.0",
-    "@babel/preset-env": "^7.2.0",
-    "@babel/preset-flow": "^7.0.0",
-    "@babel/preset-react": "^7.0.0",
-    "@rollup/plugin-alias": "^5.1.1",
+    "@babel/core": "^7.26.0",
+    "@babel/plugin-transform-runtime": "^7.26.0",
+    "@babel/preset-env": "^7.26.0",
+    "@babel/preset-flow": "^7.25.0",
+    "@babel/preset-react": "^7.26.0",
     "babel-plugin-lodash": "^3.3.4",
     "babel-plugin-macros": "^2.4.2",
     "babel-plugin-styled-components": "^1.10.0",
-    "fbjs-scripts": "^0.6.0-alpha.3",
-    "rollup": "^2.18.0",
+    "lodash": "^4.17.21",
+    "rollup": "^2.79.2",
     "rollup-plugin-auto-external": "^2.0.0",
     "rollup-plugin-babel": "^4.0.3",
     "rollup-plugin-commonjs": "^9.2.0",
-    "rollup-plugin-node-resolve": "^3.4.0"
+    "rollup-plugin-node-resolve": "^3.4.0",
+    "styled-components": "^5.3.11"
   },
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1",
-    "build": "rollup -c"
+    "build": "rollup -c && rollup -c --environment YAK"
   },
   "repository": {
     "type": "git",
@@ -72,6 +80,21 @@
     }
   },
   "dependencies": {
+    "@babel/runtime": "^7.20.0",
     "mitt": "^1.1.2"
-  }
+  },
+  "files": [
+    "lib",
+    "lib-yak",
+    "src"
+  ],
+  "module": "lib/index.mjs",
+  "browserslist": [
+    "chrome >= 61",
+    "edge >= 79",
+    "firefox >= 60",
+    "safari >= 11",
+    "ios_saf >= 11",
+    "samsung >= 8.2"
+  ]
 }

package/src/SlotFill.jsx

@@ -0,0 +1,166 @@
+import React, {useContext, useEffect, useLayoutEffect, useMemo, useRef} from 'react'
+import ReactDOM from 'react-dom'
+import styled from 'styled-components'
+import _ from 'lodash/fp'
+import {_s, callIfFunction} from '@startlibs/utils'
+import {useConstant} from './hooks/useConstant'
+import {willUseSharedState} from './hooks/willUseSharedState'
+
+export const SlotContext = React.createContext(new Map())
+const [useFillHookState, useFillHookStateRef] = willUseSharedState()
+const [useHiddenFillHookState, useHiddenFillHookStateRef] = willUseSharedState()
+
+const DEFAULT_CONTEXT = new Map()
+
+export const SlotProvider = ({children}) => {
+
+  return <SlotContext.Provider value={DEFAULT_CONTEXT}>
+    {children}
+    <React.Suspense fallback={null}><FillHooks/></React.Suspense>
+    <HiddenFillHooks/>
+  </SlotContext.Provider>
+}
+
+export const Slot = ({name,children,...rest}) => {
+
+  const ref = useRef()
+  const slotInfo = useConstant({ref})
+
+  const slots = useContext(SlotContext)
+
+  useLayoutEffect(() => {
+    const previous = slots.get(name)
+    const updates = previous?.updates || []
+    if (previous?.children) {
+      // reparent
+    }
+    slots.set(name,_.flow(
+      _.update('infos',_.union([slotInfo]))
+    )(previous))
+    updates.forEach(v => v({}))
+    return () => {
+      const previous = slots.get(name)
+      previous.infos = _.without([slotInfo],previous.infos)
+      if (!previous.infos?.length && !previous.updates?.length) {
+        slots.delete(name)
+      }
+    }
+  }, [name])
+
+  return children
+    ? <>
+      <div data-id={name} {...rest} ref={ref}/>
+      {React.Children.map(children,c => React.cloneElement(c,{...c.props,name,stack:Number.MIN_SAFE_INTEGER}))}
+    </>
+    : <div data-id={name} {...rest} ref={ref}/>
+
+}
+
+const Invisible = styled.div`display:none`
+
+const FillBeforeFlip = ({name, children, slot}) => {
+  const slots = useContext(SlotContext)
+  const ref = useRef()
+  useLayoutEffect(() => {
+    const infos = slots.get(name)?.infos || []
+    const mounted = _.flatMap(({ref}) => ref?.current,infos)
+    const clones = []
+    const getClone = () => {
+      const cloned = ref.current.cloneNode(true)
+      cloned.className = 'JS-fill-flip'
+      clones.push(cloned)
+      return cloned
+    }
+    mounted.map(_ => _.appendChild(getClone()))
+    return () => {
+      clones.forEach(el => el.remove())
+    }
+  },[])
+  return <Invisible ref={ref}>{children}</Invisible>
+}
+
+const useFillState = (name,stack) => {
+  const forceUpdate = React.useState(false)[1];
+  const slots = useContext(SlotContext)
+  const renderSlot = slots.get(name)
+  const maxStack = _.max(renderSlot?.stacks)
+  const onStack = !_.isFinite(maxStack) || maxStack === stack
+  useLayoutEffect(() => {
+
+    const slot = slots.get(name)
+    const updatedSlot = _.flow(
+      _.update('updates',_.union([forceUpdate])),
+      _.update('stacks',_.union([stack])),
+    )(slot)
+    slots.set(name, updatedSlot)
+    updatedSlot.updates.forEach(v => v({}))
+    return () => {
+      const previous = slots.get(name)
+      const index = previous.updates.indexOf(forceUpdate)
+      const next = _.flow(
+        _.update('updates',_s.removeAt(index)),
+        _.update('stacks',_s.removeAt(index))
+      )(previous)
+      slots.set(name,next)
+      next.updates.forEach(v => v({}))
+    }
+  },[])
+
+  return [renderSlot,onStack]
+}
+
+
+export const Fill = ({name, children, stack = 0, mountBeforeFlip}) => {
+  const [slot,onStack] = useFillState(name,stack)
+  if (slot?.infos && onStack) {
+    return slot?.infos.map((info) => info.ref?.current && ReactDOM.createPortal(callIfFunction(children,info),info.ref.current))
+  } else if (mountBeforeFlip) {
+    return <FillBeforeFlip name={name} slot={slot}>{children}</FillBeforeFlip>
+  } else {
+    return null
+  }
+}
+
+
+const FillHooks = ({}) => {
+  const [hooked] = useFillHookState({})
+  return Object.entries(hooked)
+    .map(([name, childs]) => childs.map(({children}, i) => <Fill key={name + i} name={name}>{children}</Fill>))
+}
+
+let uid = 0
+export const useFill = (name, children, inputs) => {
+  const [, set] = useFillHookStateRef()
+  const key = useRef(uid++)
+  useLayoutEffect(() => {
+    if (children) {
+      set(_.update([name], (list = []) => {
+        const index = _.findIndex(['key',key.current],list)
+        const value = {children,key:key.current}
+        if (index >= 0 ) {
+          return _.set([index],value,list)
+        } else {
+          return list.concat(value)
+        }
+      } ))
+    } else {
+      set(_.update([name], _.differenceBy('key',_, [{children,key:key.current}])))
+    }
+  }, inputs || children)
+
+  useLayoutEffect(() =>
+    () => set(_.update([name], _.differenceBy('key',_, [{key:key.current}])))
+  ,[])
+}
+
+const HiddenFillHooks = ({}) => {
+  const [hookedChildren] = useHiddenFillHookState({})
+  return <div>{Object.values(hookedChildren)}</div>
+}
+
+export const useHiddenFill = (children, inputs) => {
+  const [, set] = useHiddenFillHookStateRef()
+  const [uid] = useMemo(()=>_.uniqueId(""),[])
+  set(_.set([uid], children ? React.cloneElement(children,{key:uid}) : null))
+  useEffect(()=> () => set(_.unset([uid])),[])
+}