@builder.io/sdk-qwik 0.16.6 → 0.16.7

package/lib/node/constants/sdk-name.qwik.mjs

@@ -0,0 +1,15 @@
+import { TARGET } from "./target.qwik.mjs";
+const SDK_NAME_FOR_TARGET = (() => {
+  switch (TARGET) {
+    case "rsc":
+      return "react-nextjs";
+    case "reactNative":
+      return "react-native";
+    default:
+      return TARGET;
+  }
+})();
+const SDK_NAME = `@builder.io/sdk-${SDK_NAME_FOR_TARGET}`;
+export {
+  SDK_NAME
+};

package/lib/node/constants/sdk-version.qwik.cjs

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const SDK_VERSION = "0.16.7";
+exports.SDK_VERSION = SDK_VERSION;

package/lib/node/constants/sdk-version.qwik.mjs

@@ -0,0 +1,4 @@
+const SDK_VERSION = "0.16.7";
+export {
+  SDK_VERSION
+};

package/lib/node/constants/target.qwik.cjs

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const TARGET = "qwik";
+exports.TARGET = TARGET;

package/lib/node/constants/target.qwik.mjs

@@ -0,0 +1,4 @@
+const TARGET = "qwik";
+export {
+  TARGET
+};

package/lib/node/context/builder.context.qwik.cjs

@@ -0,0 +1,4 @@
+"use strict";
+const qwik = require("@builder.io/qwik");
+const builderContext = qwik.createContextId("Builder");
+module.exports = builderContext;

package/lib/node/context/builder.context.qwik.mjs

@@ -0,0 +1,5 @@
+import { createContextId } from "@builder.io/qwik";
+const builderContext = createContextId("Builder");
+export {
+  builderContext as default
+};

package/lib/node/context/components.context.qwik.cjs

@@ -0,0 +1,4 @@
+"use strict";
+const qwik = require("@builder.io/qwik");
+const ComponentsContext = qwik.createContextId("Components");
+module.exports = ComponentsContext;

package/lib/node/context/components.context.qwik.mjs

@@ -0,0 +1,5 @@
+import { createContextId } from "@builder.io/qwik";
+const ComponentsContext = createContextId("Components");
+export {
+  ComponentsContext as default
+};

package/lib/node/functions/camel-to-kebab-case.qwik.cjs

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const camelToKebabCase = (str) => str ? str.replace(/([a-z0-9]|(?=[A-Z]))([A-Z])/g, "$1-$2").toLowerCase() : "";
+exports.camelToKebabCase = camelToKebabCase;

package/lib/node/functions/camel-to-kebab-case.qwik.mjs

@@ -0,0 +1,4 @@
+const camelToKebabCase = (str) => str ? str.replace(/([a-z0-9]|(?=[A-Z]))([A-Z])/g, "$1-$2").toLowerCase() : "";
+export {
+  camelToKebabCase
+};

package/lib/node/functions/deopt.qwik.cjs

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+function deoptSignal(value) {
+  return value;
+}
+exports.deoptSignal = deoptSignal;

package/lib/node/functions/deopt.qwik.mjs

@@ -0,0 +1,6 @@
+function deoptSignal(value) {
+  return value;
+}
+export {
+  deoptSignal
+};

package/lib/node/functions/evaluate/browser-runtime/browser.qwik.cjs

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const helpers = require("../helpers.qwik.cjs");
+const runInBrowser = ({ code, builder, context, event, localState, rootSetState, rootState }) => {
+  const functionArgs = helpers.getFunctionArguments({
+    builder,
+    context,
+    event,
+    state: flattenState({
+      rootState,
+      localState,
+      rootSetState
+    })
+  });
+  return new Function(...functionArgs.map(([name]) => name), code)(...functionArgs.map(([, value]) => value));
+};
+function flattenState({ rootState, localState, rootSetState }) {
+  return new Proxy(rootState, {
+    get: (target, prop) => {
+      if (localState && prop in localState)
+        return localState[prop];
+      const val = target[prop];
+      if (typeof val === "object" && val !== null)
+        return flattenState({
+          rootState: val,
+          localState: void 0,
+          rootSetState: rootSetState ? (subState) => {
+            target[prop] = subState;
+            rootSetState(target);
+          } : void 0
+        });
+      return val;
+    },
+    set: (target, prop, value) => {
+      if (localState && prop in localState)
+        throw new Error("Writing to local state is not allowed as it is read-only.");
+      target[prop] = value;
+      rootSetState == null ? void 0 : rootSetState(target);
+      return true;
+    }
+  });
+}
+exports.flattenState = flattenState;
+exports.runInBrowser = runInBrowser;

package/lib/node/functions/evaluate/browser-runtime/browser.qwik.mjs

@@ -0,0 +1,44 @@
+import { getFunctionArguments } from "../helpers.qwik.mjs";
+const runInBrowser = ({ code, builder, context, event, localState, rootSetState, rootState }) => {
+  const functionArgs = getFunctionArguments({
+    builder,
+    context,
+    event,
+    state: flattenState({
+      rootState,
+      localState,
+      rootSetState
+    })
+  });
+  return new Function(...functionArgs.map(([name]) => name), code)(...functionArgs.map(([, value]) => value));
+};
+function flattenState({ rootState, localState, rootSetState }) {
+  return new Proxy(rootState, {
+    get: (target, prop) => {
+      if (localState && prop in localState)
+        return localState[prop];
+      const val = target[prop];
+      if (typeof val === "object" && val !== null)
+        return flattenState({
+          rootState: val,
+          localState: void 0,
+          rootSetState: rootSetState ? (subState) => {
+            target[prop] = subState;
+            rootSetState(target);
+          } : void 0
+        });
+      return val;
+    },
+    set: (target, prop, value) => {
+      if (localState && prop in localState)
+        throw new Error("Writing to local state is not allowed as it is read-only.");
+      target[prop] = value;
+      rootSetState == null ? void 0 : rootSetState(target);
+      return true;
+    }
+  });
+}
+export {
+  flattenState,
+  runInBrowser
+};

package/lib/node/functions/evaluate/choose-eval.qwik.cjs

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const build = require("@builder.io/qwik/build");
+const browser = require("./browser-runtime/browser.qwik.cjs");
+const nodeRuntime = require("./node-runtime/node-runtime.qwik.cjs");
+const shouldForceBrowserRuntimeInNode = require("./should-force-browser-runtime-in-node.qwik.cjs");
+const chooseBrowserOrServerEval = (args) => build.isBrowser || shouldForceBrowserRuntimeInNode.shouldForceBrowserRuntimeInNode() ? browser.runInBrowser(args) : nodeRuntime.runInNode(args);
+exports.chooseBrowserOrServerEval = chooseBrowserOrServerEval;

package/lib/node/functions/evaluate/choose-eval.qwik.mjs

@@ -0,0 +1,8 @@
+import { isBrowser } from "@builder.io/qwik/build";
+import { runInBrowser } from "./browser-runtime/browser.qwik.mjs";
+import { runInNode } from "./node-runtime/node-runtime.qwik.mjs";
+import { shouldForceBrowserRuntimeInNode } from "./should-force-browser-runtime-in-node.qwik.mjs";
+const chooseBrowserOrServerEval = (args) => isBrowser || shouldForceBrowserRuntimeInNode() ? runInBrowser(args) : runInNode(args);
+export {
+  chooseBrowserOrServerEval
+};

package/lib/node/functions/evaluate/evaluate.qwik.cjs

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const logger = require("../../helpers/logger.qwik.cjs");
+const chooseEval = require("./choose-eval.qwik.cjs");
+const helpers = require("./helpers.qwik.cjs");
+const _EvalCache = class _EvalCache2 {
+  static getCacheKey(args) {
+    return JSON.stringify({
+      ...args,
+      // replace the event with a random number to break cache
+      // thats because we can't serialize the event object due to circular refs in DOM node refs.
+      event: args.event ? Math.random() : void 0
+    });
+  }
+  static getCachedValue(key) {
+    const cachedVal = _EvalCache2.cache.get(key);
+    return cachedVal;
+  }
+  static setCachedValue(key, value) {
+    if (_EvalCache2.cache.size > 20)
+      _EvalCache2.cache.delete(_EvalCache2.cache.keys().next().value);
+    _EvalCache2.cache.set(key, {
+      value
+    });
+  }
+};
+_EvalCache.cacheLimit = 20;
+_EvalCache.cache = /* @__PURE__ */ new Map();
+let EvalCache = _EvalCache;
+function evaluate({ code, context, localState, rootState, rootSetState, event, isExpression = true, enableCache }) {
+  if (code === "")
+    return void 0;
+  const args = {
+    code: helpers.parseCode(code, {
+      isExpression
+    }),
+    builder: helpers.getBuilderGlobals(),
+    context,
+    event,
+    rootSetState,
+    rootState,
+    localState
+  };
+  if (enableCache) {
+    const cacheKey = EvalCache.getCacheKey(args);
+    const cachedValue = EvalCache.getCachedValue(cacheKey);
+    if (cachedValue)
+      return cachedValue.value;
+  }
+  try {
+    const newEval = chooseEval.chooseBrowserOrServerEval(args);
+    if (enableCache) {
+      const cacheKey = EvalCache.getCacheKey(args);
+      EvalCache.setCachedValue(cacheKey, newEval);
+    }
+    return newEval;
+  } catch (e) {
+    logger.logger.error("Failed code evaluation: " + e.message, {
+      code
+    });
+    return void 0;
+  }
+}
+exports.evaluate = evaluate;

package/lib/node/functions/evaluate/evaluate.qwik.mjs

@@ -0,0 +1,64 @@
+import { logger } from "../../helpers/logger.qwik.mjs";
+import { chooseBrowserOrServerEval } from "./choose-eval.qwik.mjs";
+import { parseCode, getBuilderGlobals } from "./helpers.qwik.mjs";
+const _EvalCache = class _EvalCache2 {
+  static getCacheKey(args) {
+    return JSON.stringify({
+      ...args,
+      // replace the event with a random number to break cache
+      // thats because we can't serialize the event object due to circular refs in DOM node refs.
+      event: args.event ? Math.random() : void 0
+    });
+  }
+  static getCachedValue(key) {
+    const cachedVal = _EvalCache2.cache.get(key);
+    return cachedVal;
+  }
+  static setCachedValue(key, value) {
+    if (_EvalCache2.cache.size > 20)
+      _EvalCache2.cache.delete(_EvalCache2.cache.keys().next().value);
+    _EvalCache2.cache.set(key, {
+      value
+    });
+  }
+};
+_EvalCache.cacheLimit = 20;
+_EvalCache.cache = /* @__PURE__ */ new Map();
+let EvalCache = _EvalCache;
+function evaluate({ code, context, localState, rootState, rootSetState, event, isExpression = true, enableCache }) {
+  if (code === "")
+    return void 0;
+  const args = {
+    code: parseCode(code, {
+      isExpression
+    }),
+    builder: getBuilderGlobals(),
+    context,
+    event,
+    rootSetState,
+    rootState,
+    localState
+  };
+  if (enableCache) {
+    const cacheKey = EvalCache.getCacheKey(args);
+    const cachedValue = EvalCache.getCachedValue(cacheKey);
+    if (cachedValue)
+      return cachedValue.value;
+  }
+  try {
+    const newEval = chooseBrowserOrServerEval(args);
+    if (enableCache) {
+      const cacheKey = EvalCache.getCacheKey(args);
+      EvalCache.setCachedValue(cacheKey, newEval);
+    }
+    return newEval;
+  } catch (e) {
+    logger.error("Failed code evaluation: " + e.message, {
+      code
+    });
+    return void 0;
+  }
+}
+export {
+  evaluate
+};

package/lib/node/functions/evaluate/helpers.qwik.cjs

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const isBrowser = require("../is-browser.qwik.cjs");
+const isEditing = require("../is-editing.qwik.cjs");
+const helpers = require("../track/helpers.qwik.cjs");
+const getFunctionArguments = ({ builder, context, event, state }) => {
+  return Object.entries({
+    state,
+    Builder: builder,
+    // legacy
+    builder,
+    context,
+    event
+  });
+};
+const getBuilderGlobals = () => ({
+  isEditing: isEditing.isEditing(),
+  isBrowser: isBrowser.isBrowser(),
+  isServer: !isBrowser.isBrowser(),
+  getUserAttributes: () => helpers.getUserAttributes()
+});
+const parseCode = (code, { isExpression = true }) => {
+  const useReturn = (
+    // we disable this for cases where we definitely don't want a return
+    isExpression && !(code.includes(";") || code.includes(" return ") || code.trim().startsWith("return "))
+  );
+  const useCode = useReturn ? `return (${code});` : code;
+  return useCode;
+};
+exports.getBuilderGlobals = getBuilderGlobals;
+exports.getFunctionArguments = getFunctionArguments;
+exports.parseCode = parseCode;

package/lib/node/functions/evaluate/helpers.qwik.mjs

@@ -0,0 +1,32 @@
+import { isBrowser } from "../is-browser.qwik.mjs";
+import { isEditing } from "../is-editing.qwik.mjs";
+import { getUserAttributes } from "../track/helpers.qwik.mjs";
+const getFunctionArguments = ({ builder, context, event, state }) => {
+  return Object.entries({
+    state,
+    Builder: builder,
+    // legacy
+    builder,
+    context,
+    event
+  });
+};
+const getBuilderGlobals = () => ({
+  isEditing: isEditing(),
+  isBrowser: isBrowser(),
+  isServer: !isBrowser(),
+  getUserAttributes: () => getUserAttributes()
+});
+const parseCode = (code, { isExpression = true }) => {
+  const useReturn = (
+    // we disable this for cases where we definitely don't want a return
+    isExpression && !(code.includes(";") || code.includes(" return ") || code.trim().startsWith("return "))
+  );
+  const useCode = useReturn ? `return (${code});` : code;
+  return useCode;
+};
+export {
+  getBuilderGlobals,
+  getFunctionArguments,
+  parseCode
+};

package/lib/node/functions/evaluate/node-runtime/init.qwik.cjs

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const ivm = require("isolated-vm");
+const nodeRuntime = require("./node-runtime.qwik.cjs");
+const initializeNodeRuntime = (args) => {
+  const { ivmIsolateOptions } = args || {};
+  nodeRuntime.setIvm(ivm, ivmIsolateOptions);
+};
+exports.initializeNodeRuntime = initializeNodeRuntime;

package/lib/node/functions/evaluate/node-runtime/init.qwik.mjs

@@ -0,0 +1,9 @@
+import ivm from "isolated-vm";
+import { setIvm } from "./node-runtime.qwik.mjs";
+const initializeNodeRuntime = (args) => {
+  const { ivmIsolateOptions } = args || {};
+  setIvm(ivm, ivmIsolateOptions);
+};
+export {
+  initializeNodeRuntime
+};

package/lib/node/functions/evaluate/node-runtime/node-runtime.qwik.cjs

@@ -0,0 +1,146 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const sdkName = require("../../../constants/sdk-name.qwik.cjs");
+const logger = require("../../../helpers/logger.qwik.cjs");
+const fastClone = require("../../fast-clone.qwik.cjs");
+const set = require("../../set.qwik.cjs");
+const helpers = require("../helpers.qwik.cjs");
+const safeDynamicRequire = require("./safeDynamicRequire.qwik.cjs");
+const getSyncValName = (key) => `bldr_${key}_sync`;
+const BUILDER_SET_STATE_NAME = "BUILDER_SET_STATE";
+const INJECTED_IVM_GLOBAL = "BUILDER_IVM";
+const REF_TO_PROXY_FN = `
+var refToProxy = (obj) => {
+  if (typeof obj !== 'object' || obj === null) {
+    return obj;
+  }
+  return new Proxy({}, {
+    get(target, key) {
+        if (key === 'copySync') {
+          return () => obj.copySync();
+        }
+        const val = obj.getSync(key);
+        if (typeof val?.getSync === 'function') {
+            return refToProxy(val);
+        }
+        return val;
+    },
+    set(target, key, value) {
+        const v = typeof value === 'object' ? new ${INJECTED_IVM_GLOBAL}.Reference(value) : value;
+        obj.setSync(key, v);
+        ${BUILDER_SET_STATE_NAME}(key, value)
+    },
+    deleteProperty(target, key) {
+        obj.deleteSync(key);
+    }
+  })
+}
+`;
+const processCode = ({ code, args }) => {
+  const fnArgs = args.map(([name]) => `var ${name} = refToProxy(${getSyncValName(name)}); `).join("");
+  return `
+${REF_TO_PROXY_FN}
+${fnArgs}
+function theFunction() {
+  ${code}
+}
+
+const output = theFunction()
+
+if (typeof output === 'object' && output !== null) {
+  return JSON.stringify(output.copySync ? output.copySync() : output);
+} else {
+  return output;
+}
+`;
+};
+let IVM_INSTANCE = null;
+let IVM_CONTEXT = null;
+const setIvm = (ivm, options = {}) => {
+  IVM_INSTANCE = ivm;
+  setIsolateContext(options);
+};
+const SHOULD_MENTION_INITIALIZE_SCRIPT = sdkName.SDK_NAME === "@builder.io/sdk-react-nextjs" || sdkName.SDK_NAME === "@builder.io/sdk-react" || sdkName.SDK_NAME === "@builder.io/sdk-qwik";
+const getIvm = () => {
+  try {
+    if (IVM_INSTANCE)
+      return IVM_INSTANCE;
+    const dynRequiredIvm = safeDynamicRequire.safeDynamicRequire("isolated-vm");
+    if (dynRequiredIvm)
+      return dynRequiredIvm;
+  } catch (error) {
+    logger.logger.error("isolated-vm import error.", error);
+  }
+  const ERROR_MESSAGE = `${logger.MSG_PREFIX}could not import \`isolated-vm\` module for safe script execution on a Node server.
+    
+    SOLUTION: In a server-only execution path within your application, do one of the following:
+  
+    ${SHOULD_MENTION_INITIALIZE_SCRIPT ? `- import and call \`initializeNodeRuntime()\` from "${sdkName.SDK_NAME}/node/init".` : ""}
+    - add the following import: \`await import('isolated-vm')\`.
+
+    For more information, visit https://builder.io/c/docs/integration-tips#enabling-data-bindings-in-node-environments`;
+  throw new Error(ERROR_MESSAGE);
+};
+function setIsolateContext(options = {
+  memoryLimit: 128
+}) {
+  const ivm = getIvm();
+  const isolate = new ivm.Isolate(options);
+  const context = isolate.createContextSync();
+  const jail = context.global;
+  jail.setSync("global", jail.derefInto());
+  jail.setSync("log", function(...logArgs) {
+    console.log(...logArgs);
+  });
+  jail.setSync(INJECTED_IVM_GLOBAL, ivm);
+  IVM_CONTEXT = context;
+  return context;
+}
+const getIsolateContext = () => {
+  if (IVM_CONTEXT)
+    return IVM_CONTEXT;
+  const context = setIsolateContext();
+  return context;
+};
+const runInNode = ({ code, builder, context, event, localState, rootSetState, rootState }) => {
+  const ivm = getIvm();
+  const state = fastClone.fastClone({
+    ...rootState,
+    ...localState
+  });
+  const args = helpers.getFunctionArguments({
+    builder,
+    context,
+    event,
+    state
+  });
+  const isolateContext = getIsolateContext();
+  const jail = isolateContext.global;
+  jail.setSync(BUILDER_SET_STATE_NAME, function(key, value) {
+    set.set(rootState, key, value);
+    rootSetState == null ? void 0 : rootSetState(rootState);
+  });
+  args.forEach(([key, arg]) => {
+    const val = typeof arg === "object" ? new ivm.Reference(
+      // workaround: methods with default values for arguments is not being cloned over
+      key === "builder" ? {
+        ...arg,
+        getUserAttributes: () => arg.getUserAttributes()
+      } : arg
+    ) : null;
+    jail.setSync(getSyncValName(key), val);
+  });
+  const evalStr = processCode({
+    code,
+    args
+  });
+  const resultStr = isolateContext.evalClosureSync(evalStr);
+  try {
+    const res = JSON.parse(resultStr);
+    return res;
+  } catch (_error) {
+    return resultStr;
+  }
+};
+exports.runInNode = runInNode;
+exports.setIvm = setIvm;