@joystick.js/node-canary 0.0.0-canary.47 → 0.0.0-canary.471

package/dist/validation/lib/constants.js

@@ -1,162 +0,0 @@
-import { createRequire } from "module";
-import { fileURLToPath } from "url";
-import { dirname } from "path";
-import { isObject, isArray, isString } from "./typeValidators";
-import validateType from "./validateType";
-import isArrayPath from "./isArrayPath";
-const require2 = createRequire(import.meta.url);
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-const types = [
-  "any",
-  "array",
-  "boolean",
-  "float",
-  "integer",
-  "number",
-  "object",
-  "string"
-];
-var constants_default = {
-  types,
-  rules: {
-    allowedValues: (ruleValue, inputValue, parentPath) => {
-      const isValid = ruleValue.includes(inputValue);
-      if (!isValid) {
-        return {
-          valid: false,
-          errors: [
-            `Field ${parentPath} only allows the following values: ${ruleValue.join(", ")}.`
-          ]
-        };
-      }
-      return {
-        valid: true,
-        errors: []
-      };
-    },
-    element: async (ruleValue, inputValue, parentPath) => {
-      if (inputValue && (isObject(ruleValue) || isString(ruleValue)) && isArray(inputValue)) {
-        const inputWithSchemaPath = process.env.NODE_ENV === "test" ? `../inputWithSchema` : `${__dirname.replace("/dist/validation/lib", "/dist/validation").replace("/src/validation/lib", "/src/validation")}/inputWithSchema/index.js`;
-        const inputWithSchemaFile = await import(inputWithSchemaPath);
-        const inputWithSchema = inputWithSchemaFile.default;
-        const validateInputWithSchema = isObject(inputWithSchema) ? inputWithSchema.default : inputWithSchema;
-        const elementErrors = await Promise.all(inputValue.flatMap(async (element, elementIndex) => {
-          const errors = await validateInputWithSchema(element, isString(ruleValue) ? { type: ruleValue } : ruleValue, `${parentPath}.${elementIndex}`);
-          return errors.flatMap((error) => error);
-        }));
-        return {
-          valid: elementErrors.length === 0,
-          errors: elementErrors.flatMap((elementError) => elementError)
-        };
-      }
-      return {
-        valid: true,
-        errors: []
-      };
-    },
-    fields: async (ruleValue, inputValue, parentPath) => {
-      if (isObject(ruleValue) && isObject(inputValue)) {
-        const inputWithSchemaPath = process.env.NODE_ENV === "test" ? `../inputWithSchema` : `${__dirname.replace("/dist/validation/lib", "/dist/validation").replace("/src/validation/lib", "/src/validation")}/inputWithSchema/index.js`;
-        const inputWithSchemaFile = await import(inputWithSchemaPath);
-        const inputWithSchema = inputWithSchemaFile.default;
-        const validateInputWithSchema = isObject(inputWithSchema) ? inputWithSchema.default : inputWithSchema;
-        const input = isArrayPath(parentPath) ? inputValue : { [parentPath]: inputValue };
-        const errors = await validateInputWithSchema(input, ruleValue, parentPath);
-        return {
-          valid: errors.length === 0,
-          errors: [...errors]
-        };
-      }
-      return {
-        valid: false,
-        errors: [
-          `Field ${parentPath} schema rule and input value for element must be of type object.`
-        ]
-      };
-    },
-    max: (ruleValue, inputValue, parentPath) => {
-      const valid = inputValue <= ruleValue;
-      if (!valid) {
-        return {
-          valid: false,
-          errors: [`Field ${parentPath} must be less than or equal to ${ruleValue}.`]
-        };
-      }
-      return {
-        valid: true,
-        errors: []
-      };
-    },
-    min: (ruleValue, inputValue, parentPath) => {
-      const valid = inputValue >= ruleValue;
-      if (!valid) {
-        return {
-          valid: false,
-          errors: [
-            `Field ${parentPath} must be greater than or equal to ${ruleValue}.`
-          ]
-        };
-      }
-      return {
-        valid: true,
-        errors: []
-      };
-    },
-    optional: (ruleValue, inputValue, parentPath) => {
-      const valid = ruleValue === false ? !!inputValue : true;
-      if (!valid) {
-        return {
-          valid: false,
-          errors: [`Field ${parentPath} is required.`]
-        };
-      }
-      return {
-        valid: true,
-        errors: []
-      };
-    },
-    regex: (ruleValue, inputValue, parentPath) => {
-      const valid = new RegExp(ruleValue).test(inputValue);
-      if (!valid) {
-        return {
-          valid: false,
-          errors: [`Field ${parentPath} must conform to regex: ${ruleValue}.`]
-        };
-      }
-      return {
-        valid: true,
-        errors: []
-      };
-    },
-    required: (ruleValue, inputValue, parentPath) => {
-      const valid = ruleValue === false ? true : !!inputValue;
-      if (!valid) {
-        return {
-          valid: false,
-          errors: [`Field ${parentPath} is required.`]
-        };
-      }
-      return {
-        valid: true,
-        errors: []
-      };
-    },
-    type: (ruleValue, inputValue, parentPath) => {
-      const valid = validateType(ruleValue, inputValue);
-      if (inputValue && !valid) {
-        return {
-          valid: false,
-          errors: [`Field ${parentPath} must be of type ${ruleValue}.`]
-        };
-      }
-      return {
-        valid: true,
-        errors: []
-      };
-    }
-  }
-};
-export {
-  constants_default as default
-};

package/dist/validation/lib/getValueFromObject.js

@@ -1,12 +0,0 @@
-const getValueFromObject = (object, path) => {
-  if (!path)
-    return object;
-  if (!object)
-    return void 0;
-  const properties = path.split(".");
-  return getValueFromObject(object[properties.shift()], properties.join("."));
-};
-var getValueFromObject_default = getValueFromObject;
-export {
-  getValueFromObject_default as default
-};

package/dist/validation/lib/getValueFromObject.test.js

@@ -1,7 +0,0 @@
-import getValueFromObject from "./getValueFromObject";
-describe("validation/lib/getValueFromObject.js", () => {
-  test("returns undefined if object is not passed", () => {
-    const value = getValueFromObject();
-    expect(value).toBe(void 0);
-  });
-});

package/dist/validation/lib/isArrayPath.js

@@ -1,6 +0,0 @@
-var isArrayPath_default = (path = "") => {
-  return new RegExp(/\.[0-9]+\.?/g).test(path);
-};
-export {
-  isArrayPath_default as default
-};

package/dist/validation/lib/throwError.js

@@ -1,6 +0,0 @@
-var throwError_default = (message) => {
-  throw new Error(`[joystick.validation] ${message}`);
-};
-export {
-  throwError_default as default
-};

package/dist/validation/lib/typeValidators.js

@@ -1,38 +0,0 @@
-const isAny = (value) => {
-  return !!value;
-};
-const isFunction = (value) => {
-  return typeof value === "function";
-};
-const isObject = (value) => {
-  return !!(value && typeof value === "object" && !Array.isArray(value));
-};
-const isArray = (value) => {
-  return !!Array.isArray(value);
-};
-const isBoolean = (value) => {
-  return value === true || value === false;
-};
-const isFloat = (value) => {
-  return Number(value) === value && value % 1 !== 0;
-};
-const isInteger = (value) => {
-  return Number(value) === value && value % 1 === 0;
-};
-const isNumber = (value) => {
-  return Number(value) === value;
-};
-const isString = (value) => {
-  return typeof value === "string";
-};
-export {
-  isAny,
-  isArray,
-  isBoolean,
-  isFloat,
-  isFunction,
-  isInteger,
-  isNumber,
-  isObject,
-  isString
-};

package/dist/validation/lib/validateType.js

@@ -1,33 +0,0 @@
-import {
-  isArray,
-  isBoolean,
-  isFloat,
-  isInteger,
-  isNumber,
-  isObject,
-  isString,
-  isAny
-} from "./typeValidators";
-var validateType_default = (type, value) => {
-  switch (type) {
-    case "any":
-      return isAny(value);
-    case "array":
-      return isArray(value);
-    case "boolean":
-      return isBoolean(value);
-    case "float":
-      return isFloat(value);
-    case "integer":
-      return isInteger(value);
-    case "number":
-      return isNumber(value);
-    case "object":
-      return isObject(value);
-    case "string":
-      return isString(value);
-  }
-};
-export {
-  validateType_default as default
-};

package/dist/validation/schema/index.js

@@ -1,44 +0,0 @@
-import throwError from "../lib/throwError";
-import { isObject } from "../lib/typeValidators";
-import constants from "../lib/constants";
-const validateRuleType = (schema) => {
-  Object.entries(schema).forEach(([field, rules]) => {
-    if (rules && rules.type && !constants.types.includes(rules.type)) {
-      throw new Error(`Invalid value for schema field "${field}" type rule. ${rules.type} is not supported. Use one of the following: ${constants.types.slice(0, constants.types.length - 1).join(", ")}, or ${constants.types[constants.types.length - 1]}.`);
-    }
-  });
-};
-const validateRuleNames = (schema) => {
-  Object.entries(schema).forEach(([field, rules]) => {
-    Object.keys(rules).forEach((ruleName) => {
-      const ruleNames = Object.keys(constants.rules);
-      if (!ruleNames.includes(ruleName)) {
-        throw new Error(`Invalid rule name ${ruleName} in rule for ${field} field.`);
-      }
-    });
-  });
-};
-const validateRulesAreObjects = (schema) => {
-  Object.entries(schema).forEach(([field, rules]) => {
-    if (!isObject(rules)) {
-      throw new Error(`Must pass an object containing rules to validate by for ${field} field.`);
-    }
-  });
-};
-const validateSchemaStructure = (schema) => {
-  validateRulesAreObjects(schema);
-  validateRuleNames(schema);
-  validateRuleType(schema);
-};
-var schema_default = (schema = null) => {
-  if (!schema) {
-    throwError("Must pass schema object.");
-  }
-  if (schema && !isObject(schema)) {
-    throwError("Must pass schema as an object.");
-  }
-  validateSchemaStructure(schema);
-};
-export {
-  schema_default as default
-};

package/dist/websockets/emitWebsocketEvent.js

@@ -1,12 +0,0 @@
-var emitWebsocketEvent_default = (emitterId = "", eventName = "", payload = {}) => {
-  const emitter = joystick?.emitters[emitterId];
-  if (emitter && Array.isArray(emitter)) {
-    for (let i = 0; i < emitter?.length; i += 1) {
-      const emitterRecipient = emitter[i];
-      emitterRecipient.emit(eventName, payload);
-    }
-  }
-};
-export {
-  emitWebsocketEvent_default as default
-};

package/dist/websockets/index.js

@@ -1,12 +0,0 @@
-import emitWebsocketEvent from "./emitWebsocketEvent";
-var websockets_default = (serverName = "") => {
-  return {
-    send: (payload = {}, uniqueConnectionId = "") => {
-      const emitterName = uniqueConnectionId ? `${serverName}_${uniqueConnectionId}` : serverName;
-      emitWebsocketEvent(emitterName, "message", payload);
-    }
-  };
-};
-export {
-  websockets_default as default
-};

package/notes

@@ -1 +0,0 @@
-- [ ] To help with sessions, replace the get() and set() on the server with direct calls to the getter or setter (remove fetch so there's no usage of cookies/tokens/etc).