catalyst-core 0.0.1-beta.2

package/packages/create-framework-app/node_modules/.package-lock.json

@@ -0,0 +1,249 @@
+{
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "../..": {
+      "version": "0.0.1",
+      "license": "ISC",
+      "dependencies": {
+        "@babel/cli": "^7.23.0",
+        "@babel/core": "^7.23.2",
+        "@babel/node": "^7.22.19",
+        "@babel/plugin-proposal-object-rest-spread": "^7.20.7",
+        "@babel/plugin-transform-react-jsx": "^7.22.15",
+        "@babel/preset-env": "^7.23.2",
+        "@babel/preset-react": "^7.22.15",
+        "@babel/register": "^7.22.15",
+        "@loadable/babel-plugin": "^5.16.1",
+        "@loadable/component": "^5.15.3",
+        "@loadable/server": "^5.16.1",
+        "@loadable/webpack-plugin": "^5.15.2",
+        "@pmmmwh/react-refresh-webpack-plugin": "^0.5.11",
+        "@svgr/webpack": "^8.1.0",
+        "@tata1mg/router": "^0.0.1-alpha.13",
+        "acorn-loose": "^8.4.0",
+        "aws-sdk": "^2.1490.0",
+        "axios": "^0.19.2",
+        "babel-loader": "^9.1.3",
+        "babel-plugin-dynamic-import-node": "^2.3.3",
+        "babel-plugin-syntax-dynamic-import": "^6.18.0",
+        "babel-plugin-transform-class-properties": "^6.24.1",
+        "babel-plugin-transform-es2015-modules-commonjs": "^6.26.2",
+        "babel-plugin-transform-export-extensions": "^6.22.0",
+        "babel-plugin-transform-react-remove-prop-types": "^0.4.24",
+        "body-parser": "^1.20.2",
+        "compression": "^1.7.4",
+        "cookie-parser": "^1.4.6",
+        "css-hot-loader": "^1.4.4",
+        "css-loader": "^6.8.1",
+        "css-modules-require-hook": "^4.2.3",
+        "dotenv-webpack": "^8.0.1",
+        "esm-module-alias": "^2.0.3",
+        "express": "^4.18.2",
+        "express-static-gzip": "^2.1.7",
+        "file-loader": "^6.2.0",
+        "helmet": "^7.0.0",
+        "html-loader": "^4.2.0",
+        "img-loader": "^4.0.0",
+        "isomorphic-dompurify": "^1.13.0",
+        "lodash.template": "^4.5.0",
+        "mini-css-extract-plugin": "^2.7.6",
+        "module-alias": "^2.2.3",
+        "node-dev": "^7.4.3",
+        "postcss-loader": "^7.3.3",
+        "react": "^18.2.0",
+        "react-dom": "^18.2.0",
+        "react-redux": "^8.1.3",
+        "react-refresh": "^0.14.0",
+        "react-router-dom": "^6.16.0",
+        "redux": "^4.2.1",
+        "redux-logger": "^3.0.6",
+        "redux-thunk": "^2.4.2",
+        "sass": "^1.69.5",
+        "sass-loader": "^13.3.2",
+        "sass-resources-loader": "^2.2.5",
+        "ua-parser-js": "^1.0.37",
+        "url-loader": "^4.1.1",
+        "webpack": "^5.88.2",
+        "webpack-bundle-analyzer": "^4.9.1",
+        "webpack-cli": "^5.1.4",
+        "webpack-dev-server": "^4.15.1",
+        "webpack-merge": "^5.9.0",
+        "webpack-node-externals": "^3.0.0",
+        "winston": "^3.11.0",
+        "winston-daily-rotate-file": "^5.0.0"
+      },
+      "bin": {
+        "catalyst": "bin/catalyst.js",
+        "framework": "bin/framework.js"
+      },
+      "devDependencies": {
+        "@babel/cli": "^7.23.0",
+        "@babel/core": "^7.23.2",
+        "@babel/node": "^7.22.19",
+        "@babel/plugin-proposal-object-rest-spread": "^7.20.7",
+        "@babel/plugin-transform-react-jsx": "^7.22.15",
+        "@babel/preset-env": "^7.23.2",
+        "@babel/preset-react": "^7.22.15",
+        "@babel/register": "^7.22.15",
+        "@pmmmwh/react-refresh-webpack-plugin": "^0.5.11",
+        "babel-loader": "^9.1.3",
+        "babel-plugin-dynamic-import-node": "^2.3.3",
+        "babel-plugin-syntax-dynamic-import": "^6.18.0",
+        "babel-plugin-transform-class-properties": "^6.24.1",
+        "babel-plugin-transform-es2015-modules-commonjs": "^6.26.2",
+        "babel-plugin-transform-export-extensions": "^6.22.0",
+        "body-parser": "^1.20.2",
+        "compression": "^1.7.4",
+        "cookie-parser": "^1.4.6",
+        "css-loader": "^6.8.1",
+        "css-modules-require-hook": "^4.2.3",
+        "dotenv-webpack": "^8.0.1",
+        "express": "^4.18.2",
+        "express-static-gzip": "^2.1.7",
+        "helmet": "^7.0.0",
+        "mini-css-extract-plugin": "^2.7.6",
+        "node-dev": "^7.4.3",
+        "react-refresh": "^0.14.0",
+        "redux-logger": "^3.0.6",
+        "webpack": "^5.88.2",
+        "webpack-bundle-analyzer": "^4.9.1",
+        "webpack-cli": "^5.1.4",
+        "webpack-dev-server": "^4.15.1",
+        "webpack-merge": "^5.9.0"
+      },
+      "peerDependencies": {
+        "isomorphic-dompurify": "^1.9.0",
+        "react": "^18.2.0",
+        "react-dom": "^18.2.0",
+        "react-helmet-async": "^1.3.0",
+        "react-redux": "^8.0.4",
+        "react-router-dom": "^6.22.0"
+      }
+    },
+    "node_modules/ansi-regex": {
+      "extraneous": true
+    },
+    "node_modules/catalyst": {
+      "resolved": "../..",
+      "link": true
+    },
+    "node_modules/chalk": {
+      "extraneous": true
+    },
+    "node_modules/chownr": {
+      "extraneous": true
+    },
+    "node_modules/cli-cursor": {
+      "extraneous": true
+    },
+    "node_modules/cli-spinners": {
+      "extraneous": true
+    },
+    "node_modules/commander": {
+      "extraneous": true
+    },
+    "node_modules/data-uri-to-buffer": {
+      "extraneous": true
+    },
+    "node_modules/emoji-regex": {
+      "extraneous": true
+    },
+    "node_modules/fetch-blob": {
+      "extraneous": true
+    },
+    "node_modules/formdata-polyfill": {
+      "extraneous": true
+    },
+    "node_modules/fs": {
+      "extraneous": true
+    },
+    "node_modules/fs-minipass": {
+      "extraneous": true
+    },
+    "node_modules/fs-minipass/node_modules/minipass": {
+      "extraneous": true
+    },
+    "node_modules/get-east-asian-width": {
+      "extraneous": true
+    },
+    "node_modules/https": {
+      "extraneous": true
+    },
+    "node_modules/is-interactive": {
+      "extraneous": true
+    },
+    "node_modules/is-unicode-supported": {
+      "extraneous": true
+    },
+    "node_modules/kleur": {
+      "extraneous": true
+    },
+    "node_modules/log-symbols": {
+      "extraneous": true
+    },
+    "node_modules/log-symbols/node_modules/is-unicode-supported": {
+      "extraneous": true
+    },
+    "node_modules/mimic-fn": {
+      "extraneous": true
+    },
+    "node_modules/minipass": {
+      "extraneous": true
+    },
+    "node_modules/minizlib": {
+      "extraneous": true
+    },
+    "node_modules/minizlib/node_modules/minipass": {
+      "extraneous": true
+    },
+    "node_modules/mkdirp": {
+      "extraneous": true
+    },
+    "node_modules/node-domexception": {
+      "extraneous": true
+    },
+    "node_modules/node-fetch": {
+      "extraneous": true
+    },
+    "node_modules/onetime": {
+      "extraneous": true
+    },
+    "node_modules/ora": {
+      "extraneous": true
+    },
+    "node_modules/picocolors": {
+      "extraneous": true
+    },
+    "node_modules/prompts": {
+      "extraneous": true
+    },
+    "node_modules/restore-cursor": {
+      "extraneous": true
+    },
+    "node_modules/signal-exit": {
+      "extraneous": true
+    },
+    "node_modules/sisteransi": {
+      "extraneous": true
+    },
+    "node_modules/stdin-discarder": {
+      "extraneous": true
+    },
+    "node_modules/string-width": {
+      "extraneous": true
+    },
+    "node_modules/strip-ansi": {
+      "extraneous": true
+    },
+    "node_modules/tar": {
+      "extraneous": true
+    },
+    "node_modules/web-streams-polyfill": {
+      "extraneous": true
+    },
+    "node_modules/yallist": {
+      "extraneous": true
+    }
+  }
+}

package/packages/create-framework-app/templates/redux-js/node_modules/@babel/core/lib/config/caching.js

@@ -0,0 +1,261 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.assertSimpleType = assertSimpleType;
+exports.makeStrongCache = makeStrongCache;
+exports.makeStrongCacheSync = makeStrongCacheSync;
+exports.makeWeakCache = makeWeakCache;
+exports.makeWeakCacheSync = makeWeakCacheSync;
+function _gensync() {
+  const data = require("gensync");
+  _gensync = function () {
+    return data;
+  };
+  return data;
+}
+var _async = require("../gensync-utils/async.js");
+var _util = require("./util.js");
+const synchronize = gen => {
+  return _gensync()(gen).sync;
+};
+function* genTrue() {
+  return true;
+}
+function makeWeakCache(handler) {
+  return makeCachedFunction(WeakMap, handler);
+}
+function makeWeakCacheSync(handler) {
+  return synchronize(makeWeakCache(handler));
+}
+function makeStrongCache(handler) {
+  return makeCachedFunction(Map, handler);
+}
+function makeStrongCacheSync(handler) {
+  return synchronize(makeStrongCache(handler));
+}
+function makeCachedFunction(CallCache, handler) {
+  const callCacheSync = new CallCache();
+  const callCacheAsync = new CallCache();
+  const futureCache = new CallCache();
+  return function* cachedFunction(arg, data) {
+    const asyncContext = yield* (0, _async.isAsync)();
+    const callCache = asyncContext ? callCacheAsync : callCacheSync;
+    const cached = yield* getCachedValueOrWait(asyncContext, callCache, futureCache, arg, data);
+    if (cached.valid) return cached.value;
+    const cache = new CacheConfigurator(data);
+    const handlerResult = handler(arg, cache);
+    let finishLock;
+    let value;
+    if ((0, _util.isIterableIterator)(handlerResult)) {
+      value = yield* (0, _async.onFirstPause)(handlerResult, () => {
+        finishLock = setupAsyncLocks(cache, futureCache, arg);
+      });
+    } else {
+      value = handlerResult;
+    }
+    updateFunctionCache(callCache, cache, arg, value);
+    if (finishLock) {
+      futureCache.delete(arg);
+      finishLock.release(value);
+    }
+    return value;
+  };
+}
+function* getCachedValue(cache, arg, data) {
+  const cachedValue = cache.get(arg);
+  if (cachedValue) {
+    for (const {
+      value,
+      valid
+    } of cachedValue) {
+      if (yield* valid(data)) return {
+        valid: true,
+        value
+      };
+    }
+  }
+  return {
+    valid: false,
+    value: null
+  };
+}
+function* getCachedValueOrWait(asyncContext, callCache, futureCache, arg, data) {
+  const cached = yield* getCachedValue(callCache, arg, data);
+  if (cached.valid) {
+    return cached;
+  }
+  if (asyncContext) {
+    const cached = yield* getCachedValue(futureCache, arg, data);
+    if (cached.valid) {
+      const value = yield* (0, _async.waitFor)(cached.value.promise);
+      return {
+        valid: true,
+        value
+      };
+    }
+  }
+  return {
+    valid: false,
+    value: null
+  };
+}
+function setupAsyncLocks(config, futureCache, arg) {
+  const finishLock = new Lock();
+  updateFunctionCache(futureCache, config, arg, finishLock);
+  return finishLock;
+}
+function updateFunctionCache(cache, config, arg, value) {
+  if (!config.configured()) config.forever();
+  let cachedValue = cache.get(arg);
+  config.deactivate();
+  switch (config.mode()) {
+    case "forever":
+      cachedValue = [{
+        value,
+        valid: genTrue
+      }];
+      cache.set(arg, cachedValue);
+      break;
+    case "invalidate":
+      cachedValue = [{
+        value,
+        valid: config.validator()
+      }];
+      cache.set(arg, cachedValue);
+      break;
+    case "valid":
+      if (cachedValue) {
+        cachedValue.push({
+          value,
+          valid: config.validator()
+        });
+      } else {
+        cachedValue = [{
+          value,
+          valid: config.validator()
+        }];
+        cache.set(arg, cachedValue);
+      }
+  }
+}
+class CacheConfigurator {
+  constructor(data) {
+    this._active = true;
+    this._never = false;
+    this._forever = false;
+    this._invalidate = false;
+    this._configured = false;
+    this._pairs = [];
+    this._data = void 0;
+    this._data = data;
+  }
+  simple() {
+    return makeSimpleConfigurator(this);
+  }
+  mode() {
+    if (this._never) return "never";
+    if (this._forever) return "forever";
+    if (this._invalidate) return "invalidate";
+    return "valid";
+  }
+  forever() {
+    if (!this._active) {
+      throw new Error("Cannot change caching after evaluation has completed.");
+    }
+    if (this._never) {
+      throw new Error("Caching has already been configured with .never()");
+    }
+    this._forever = true;
+    this._configured = true;
+  }
+  never() {
+    if (!this._active) {
+      throw new Error("Cannot change caching after evaluation has completed.");
+    }
+    if (this._forever) {
+      throw new Error("Caching has already been configured with .forever()");
+    }
+    this._never = true;
+    this._configured = true;
+  }
+  using(handler) {
+    if (!this._active) {
+      throw new Error("Cannot change caching after evaluation has completed.");
+    }
+    if (this._never || this._forever) {
+      throw new Error("Caching has already been configured with .never or .forever()");
+    }
+    this._configured = true;
+    const key = handler(this._data);
+    const fn = (0, _async.maybeAsync)(handler, `You appear to be using an async cache handler, but Babel has been called synchronously`);
+    if ((0, _async.isThenable)(key)) {
+      return key.then(key => {
+        this._pairs.push([key, fn]);
+        return key;
+      });
+    }
+    this._pairs.push([key, fn]);
+    return key;
+  }
+  invalidate(handler) {
+    this._invalidate = true;
+    return this.using(handler);
+  }
+  validator() {
+    const pairs = this._pairs;
+    return function* (data) {
+      for (const [key, fn] of pairs) {
+        if (key !== (yield* fn(data))) return false;
+      }
+      return true;
+    };
+  }
+  deactivate() {
+    this._active = false;
+  }
+  configured() {
+    return this._configured;
+  }
+}
+function makeSimpleConfigurator(cache) {
+  function cacheFn(val) {
+    if (typeof val === "boolean") {
+      if (val) cache.forever();else cache.never();
+      return;
+    }
+    return cache.using(() => assertSimpleType(val()));
+  }
+  cacheFn.forever = () => cache.forever();
+  cacheFn.never = () => cache.never();
+  cacheFn.using = cb => cache.using(() => assertSimpleType(cb()));
+  cacheFn.invalidate = cb => cache.invalidate(() => assertSimpleType(cb()));
+  return cacheFn;
+}
+function assertSimpleType(value) {
+  if ((0, _async.isThenable)(value)) {
+    throw new Error(`You appear to be using an async cache handler, ` + `which your current version of Babel does not support. ` + `We may add support for this in the future, ` + `but if you're on the most recent version of @babel/core and still ` + `seeing this error, then you'll need to synchronously handle your caching logic.`);
+  }
+  if (value != null && typeof value !== "string" && typeof value !== "boolean" && typeof value !== "number") {
+    throw new Error("Cache keys must be either string, boolean, number, null, or undefined.");
+  }
+  return value;
+}
+class Lock {
+  constructor() {
+    this.released = false;
+    this.promise = void 0;
+    this._resolve = void 0;
+    this.promise = new Promise(resolve => {
+      this._resolve = resolve;
+    });
+  }
+  release(value) {
+    this.released = true;
+    this._resolve(value);
+  }
+}
+0 && 0;
+
+//# sourceMappingURL=caching.js.map