New Case Study:See how Anthropic automated 95% of dependency reviews with Socket.Learn More →
nuxt-envalid
Advanced tools
nuxt-envalid - npm Package Compare versions
Comparing version 0.0.1 to 0.0.2
| import { Module } from '@nuxt/types'; | ||
| import { ValidatorSpec, CleanOptions } from 'envalid'; | ||
| export * from 'envalid/dist/validators'; | ||
| export { EnvError, EnvMissingError, bool, email, host, json, makeValidator, num, port, str, testOnly, url } from 'envalid'; | ||
@@ -5,0 +5,0 @@ interface Options<T = any> { |
@@ -8,468 +8,4 @@ 'use strict'; | ||
| var name = "nuxt-envalid"; | ||
| var version = "0.0.1"; | ||
| var version = "0.0.2"; | ||
| function getAugmentedNamespace(n) { | ||
| if (n.__esModule) return n; | ||
| var a = Object.defineProperty({}, '__esModule', {value: true}); | ||
| Object.keys(n).forEach(function (k) { | ||
| var d = Object.getOwnPropertyDescriptor(n, k); | ||
| Object.defineProperty(a, k, d.get ? d : { | ||
| enumerable: true, | ||
| get: function () { | ||
| return n[k]; | ||
| } | ||
| }); | ||
| }); | ||
| return a; | ||
| } | ||
| function createCommonjsModule(fn) { | ||
| var module = { exports: {} }; | ||
| return fn(module, module.exports), module.exports; | ||
| } | ||
| /*! ***************************************************************************** | ||
| Copyright (c) Microsoft Corporation. | ||
| Permission to use, copy, modify, and/or distribute this software for any | ||
| purpose with or without fee is hereby granted. | ||
| THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH | ||
| REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY | ||
| AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, | ||
| INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM | ||
| LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR | ||
| OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR | ||
| PERFORMANCE OF THIS SOFTWARE. | ||
| ***************************************************************************** */ | ||
| /* global Reflect, Promise */ | ||
| var extendStatics = function(d, b) { | ||
| extendStatics = Object.setPrototypeOf || | ||
| ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || | ||
| function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; }; | ||
| return extendStatics(d, b); | ||
| }; | ||
| function __extends(d, b) { | ||
| if (typeof b !== "function" && b !== null) | ||
| throw new TypeError("Class extends value " + String(b) + " is not a constructor or null"); | ||
| extendStatics(d, b); | ||
| function __() { this.constructor = d; } | ||
| d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); | ||
| } | ||
| var __assign = function() { | ||
| __assign = Object.assign || function __assign(t) { | ||
| for (var s, i = 1, n = arguments.length; i < n; i++) { | ||
| s = arguments[i]; | ||
| for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p]; | ||
| } | ||
| return t; | ||
| }; | ||
| return __assign.apply(this, arguments); | ||
| }; | ||
| function __rest(s, e) { | ||
| var t = {}; | ||
| for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) | ||
| t[p] = s[p]; | ||
| if (s != null && typeof Object.getOwnPropertySymbols === "function") | ||
| for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) { | ||
| if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) | ||
| t[p[i]] = s[p[i]]; | ||
| } | ||
| return t; | ||
| } | ||
| function __decorate(decorators, target, key, desc) { | ||
| var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d; | ||
| if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc); | ||
| else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r; | ||
| return c > 3 && r && Object.defineProperty(target, key, r), r; | ||
| } | ||
| function __param(paramIndex, decorator) { | ||
| return function (target, key) { decorator(target, key, paramIndex); } | ||
| } | ||
| function __metadata(metadataKey, metadataValue) { | ||
| if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue); | ||
| } | ||
| function __awaiter(thisArg, _arguments, P, generator) { | ||
| function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } | ||
| return new (P || (P = Promise))(function (resolve, reject) { | ||
| function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } | ||
| function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } | ||
| function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } | ||
| step((generator = generator.apply(thisArg, _arguments || [])).next()); | ||
| }); | ||
| } | ||
| function __generator(thisArg, body) { | ||
| var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g; | ||
| return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g; | ||
| function verb(n) { return function (v) { return step([n, v]); }; } | ||
| function step(op) { | ||
| if (f) throw new TypeError("Generator is already executing."); | ||
| while (_) try { | ||
| if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t; | ||
| if (y = 0, t) op = [op[0] & 2, t.value]; | ||
| switch (op[0]) { | ||
| case 0: case 1: t = op; break; | ||
| case 4: _.label++; return { value: op[1], done: false }; | ||
| case 5: _.label++; y = op[1]; op = [0]; continue; | ||
| case 7: op = _.ops.pop(); _.trys.pop(); continue; | ||
| default: | ||
| if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; } | ||
| if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; } | ||
| if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; } | ||
| if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; } | ||
| if (t[2]) _.ops.pop(); | ||
| _.trys.pop(); continue; | ||
| } | ||
| op = body.call(thisArg, _); | ||
| } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; } | ||
| if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true }; | ||
| } | ||
| } | ||
| var __createBinding = Object.create ? (function(o, m, k, k2) { | ||
| if (k2 === undefined) k2 = k; | ||
| Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } }); | ||
| }) : (function(o, m, k, k2) { | ||
| if (k2 === undefined) k2 = k; | ||
| o[k2] = m[k]; | ||
| }); | ||
| function __exportStar(m, o) { | ||
| for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(o, p)) __createBinding(o, m, p); | ||
| } | ||
| function __values(o) { | ||
| var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0; | ||
| if (m) return m.call(o); | ||
| if (o && typeof o.length === "number") return { | ||
| next: function () { | ||
| if (o && i >= o.length) o = void 0; | ||
| return { value: o && o[i++], done: !o }; | ||
| } | ||
| }; | ||
| throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined."); | ||
| } | ||
| function __read(o, n) { | ||
| var m = typeof Symbol === "function" && o[Symbol.iterator]; | ||
| if (!m) return o; | ||
| var i = m.call(o), r, ar = [], e; | ||
| try { | ||
| while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value); | ||
| } | ||
| catch (error) { e = { error: error }; } | ||
| finally { | ||
| try { | ||
| if (r && !r.done && (m = i["return"])) m.call(i); | ||
| } | ||
| finally { if (e) throw e.error; } | ||
| } | ||
| return ar; | ||
| } | ||
| /** @deprecated */ | ||
| function __spread() { | ||
| for (var ar = [], i = 0; i < arguments.length; i++) | ||
| ar = ar.concat(__read(arguments[i])); | ||
| return ar; | ||
| } | ||
| /** @deprecated */ | ||
| function __spreadArrays() { | ||
| for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length; | ||
| for (var r = Array(s), k = 0, i = 0; i < il; i++) | ||
| for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++) | ||
| r[k] = a[j]; | ||
| return r; | ||
| } | ||
| function __spreadArray(to, from, pack) { | ||
| if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) { | ||
| if (ar || !(i in from)) { | ||
| if (!ar) ar = Array.prototype.slice.call(from, 0, i); | ||
| ar[i] = from[i]; | ||
| } | ||
| } | ||
| return to.concat(ar || Array.prototype.slice.call(from)); | ||
| } | ||
| function __await(v) { | ||
| return this instanceof __await ? (this.v = v, this) : new __await(v); | ||
| } | ||
| function __asyncGenerator(thisArg, _arguments, generator) { | ||
| if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); | ||
| var g = generator.apply(thisArg, _arguments || []), i, q = []; | ||
| return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i; | ||
| function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; } | ||
| function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } } | ||
| function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); } | ||
| function fulfill(value) { resume("next", value); } | ||
| function reject(value) { resume("throw", value); } | ||
| function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); } | ||
| } | ||
| function __asyncDelegator(o) { | ||
| var i, p; | ||
| return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i; | ||
| function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === "return" } : f ? f(v) : v; } : f; } | ||
| } | ||
| function __asyncValues(o) { | ||
| if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); | ||
| var m = o[Symbol.asyncIterator], i; | ||
| return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i); | ||
| function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; } | ||
| function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); } | ||
| } | ||
| function __makeTemplateObject(cooked, raw) { | ||
| if (Object.defineProperty) { Object.defineProperty(cooked, "raw", { value: raw }); } else { cooked.raw = raw; } | ||
| return cooked; | ||
| } | ||
| var __setModuleDefault = Object.create ? (function(o, v) { | ||
| Object.defineProperty(o, "default", { enumerable: true, value: v }); | ||
| }) : function(o, v) { | ||
| o["default"] = v; | ||
| }; | ||
| function __importStar(mod) { | ||
| if (mod && mod.__esModule) return mod; | ||
| var result = {}; | ||
| if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); | ||
| __setModuleDefault(result, mod); | ||
| return result; | ||
| } | ||
| function __importDefault(mod) { | ||
| return (mod && mod.__esModule) ? mod : { default: mod }; | ||
| } | ||
| function __classPrivateFieldGet(receiver, state, kind, f) { | ||
| if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter"); | ||
| if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it"); | ||
| return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver); | ||
| } | ||
| function __classPrivateFieldSet(receiver, state, value, kind, f) { | ||
| if (kind === "m") throw new TypeError("Private method is not writable"); | ||
| if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter"); | ||
| if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it"); | ||
| return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value; | ||
| } | ||
| const tslib_es6 = /*#__PURE__*/Object.freeze({ | ||
| __proto__: null, | ||
| __extends: __extends, | ||
| get __assign () { return __assign; }, | ||
| __rest: __rest, | ||
| __decorate: __decorate, | ||
| __param: __param, | ||
| __metadata: __metadata, | ||
| __awaiter: __awaiter, | ||
| __generator: __generator, | ||
| __createBinding: __createBinding, | ||
| __exportStar: __exportStar, | ||
| __values: __values, | ||
| __read: __read, | ||
| __spread: __spread, | ||
| __spreadArrays: __spreadArrays, | ||
| __spreadArray: __spreadArray, | ||
| __await: __await, | ||
| __asyncGenerator: __asyncGenerator, | ||
| __asyncDelegator: __asyncDelegator, | ||
| __asyncValues: __asyncValues, | ||
| __makeTemplateObject: __makeTemplateObject, | ||
| __importStar: __importStar, | ||
| __importDefault: __importDefault, | ||
| __classPrivateFieldGet: __classPrivateFieldGet, | ||
| __classPrivateFieldSet: __classPrivateFieldSet | ||
| }); | ||
| const tslib_1 = /*@__PURE__*/getAugmentedNamespace(tslib_es6); | ||
| var errors = createCommonjsModule(function (module, exports) { | ||
| // Surprisingly involved error subclassing | ||
| // See https://stackoverflow.com/questions/41102060/typescript-extending-error-class | ||
| exports.__esModule = true; | ||
| exports.EnvMissingError = exports.EnvError = void 0; | ||
| var EnvError = /** @class */ (function (_super) { | ||
| tslib_1.__extends(EnvError, _super); | ||
| function EnvError(message) { | ||
| var _newTarget = this.constructor; | ||
| var _this = _super.call(this, message) || this; | ||
| Object.setPrototypeOf(_this, _newTarget.prototype); | ||
| Error.captureStackTrace(_this, EnvError); | ||
| _this.name = _this.constructor.name; | ||
| return _this; | ||
| } | ||
| return EnvError; | ||
| }(TypeError)); | ||
| exports.EnvError = EnvError; | ||
| var EnvMissingError = /** @class */ (function (_super) { | ||
| tslib_1.__extends(EnvMissingError, _super); | ||
| function EnvMissingError(message) { | ||
| var _newTarget = this.constructor; | ||
| var _this = _super.call(this, message) || this; | ||
| Object.setPrototypeOf(_this, _newTarget.prototype); | ||
| Error.captureStackTrace(_this, EnvMissingError); | ||
| _this.name = _this.constructor.name; | ||
| return _this; | ||
| } | ||
| return EnvMissingError; | ||
| }(ReferenceError)); | ||
| exports.EnvMissingError = EnvMissingError; | ||
| }); | ||
| var validators = createCommonjsModule(function (module, exports) { | ||
| exports.__esModule = true; | ||
| exports.json = exports.url = exports.port = exports.host = exports.email = exports.str = exports.num = exports.bool = exports.makeValidator = void 0; | ||
| // Simplified adaptation of https://github.com/validatorjs/validator.js/blob/master/src/lib/isFQDN.js | ||
| var isFQDN = function (input) { | ||
| if (!input.length) | ||
| return false; | ||
| var parts = input.split('.'); | ||
| for (var part = void 0, i = 0; i < parts.length; i++) { | ||
| part = parts[i]; | ||
| if (!/^[a-z\u00a1-\uffff0-9-]+$/i.test(part)) | ||
| return false; | ||
| if (/[\uff01-\uff5e]/.test(part)) | ||
| return false; // disallow full-width chars | ||
| if (part[0] === '-' || part[part.length - 1] === '-') | ||
| return false; | ||
| } | ||
| return true; | ||
| }; | ||
| // "best effort" regex-based IP address check | ||
| // If you want a more exhaustive check, create your own custom validator, perhaps wrapping this | ||
| // implementation (the source of the ipv4 regex below): https://github.com/validatorjs/validator.js/blob/master/src/lib/isIP.js | ||
| var ipv4Regex = /^(([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])\.){3}([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])$/; | ||
| var ipv6Regex = /([a-f0-9]+:+)+[a-f0-9]+/; | ||
| var isIP = function (input) { | ||
| if (!input.length) | ||
| return false; | ||
| return ipv4Regex.test(input) || ipv6Regex.test(input); | ||
| }; | ||
| var EMAIL_REGEX = /^[^@\s]+@[^@\s]+\.[^@\s]+$/; // intentionally non-exhaustive | ||
| var makeValidator = function (parseFn) { | ||
| return function (spec) { | ||
| return tslib_1.__assign(tslib_1.__assign({}, spec), { _parse: parseFn }); | ||
| }; | ||
| }; | ||
| exports.makeValidator = makeValidator; | ||
| // The reason for the function wrapper is to enable the <T extends boolean = boolean> type parameter | ||
| // that enables better type inference. For more context, check out the following PR: | ||
| // https://github.com/af/envalid/pull/118 | ||
| function bool(spec) { | ||
| return (0, exports.makeValidator)(function (input) { | ||
| switch (input) { | ||
| case true: | ||
| case 'true': | ||
| case 't': | ||
| case '1': | ||
| return true; | ||
| case false: | ||
| case 'false': | ||
| case 'f': | ||
| case '0': | ||
| return false; | ||
| default: | ||
| throw new errors.EnvError("Invalid bool input: \"".concat(input, "\"")); | ||
| } | ||
| })(spec); | ||
| } | ||
| exports.bool = bool; | ||
| function num(spec) { | ||
| return (0, exports.makeValidator)(function (input) { | ||
| var coerced = parseFloat(input); | ||
| if (Number.isNaN(coerced)) | ||
| throw new errors.EnvError("Invalid number input: \"".concat(input, "\"")); | ||
| return coerced; | ||
| })(spec); | ||
| } | ||
| exports.num = num; | ||
| function str(spec) { | ||
| return (0, exports.makeValidator)(function (input) { | ||
| if (typeof input === 'string') | ||
| return input; | ||
| throw new errors.EnvError("Not a string: \"".concat(input, "\"")); | ||
| })(spec); | ||
| } | ||
| exports.str = str; | ||
| function email(spec) { | ||
| return (0, exports.makeValidator)(function (x) { | ||
| if (EMAIL_REGEX.test(x)) | ||
| return x; | ||
| throw new errors.EnvError("Invalid email address: \"".concat(x, "\"")); | ||
| })(spec); | ||
| } | ||
| exports.email = email; | ||
| function host(spec) { | ||
| return (0, exports.makeValidator)(function (input) { | ||
| if (!isFQDN(input) && !isIP(input)) { | ||
| throw new errors.EnvError("Invalid host (domain or ip): \"".concat(input, "\"")); | ||
| } | ||
| return input; | ||
| })(spec); | ||
| } | ||
| exports.host = host; | ||
| function port(spec) { | ||
| return (0, exports.makeValidator)(function (input) { | ||
| var coerced = +input; | ||
| if (Number.isNaN(coerced) || | ||
| "".concat(coerced) !== "".concat(input) || | ||
| coerced % 1 !== 0 || | ||
| coerced < 1 || | ||
| coerced > 65535) { | ||
| throw new errors.EnvError("Invalid port input: \"".concat(input, "\"")); | ||
| } | ||
| return coerced; | ||
| })(spec); | ||
| } | ||
| exports.port = port; | ||
| function url(spec) { | ||
| return (0, exports.makeValidator)(function (x) { | ||
| try { | ||
| new URL(x); | ||
| return x; | ||
| } | ||
| catch (e) { | ||
| throw new errors.EnvError("Invalid url: \"".concat(x, "\"")); | ||
| } | ||
| })(spec); | ||
| } | ||
| exports.url = url; | ||
| // It's recommended that you provide an explicit type parameter for json validation | ||
| // if you're using TypeScript. Otherwise the output will be typed as `any`. For example: | ||
| // | ||
| // cleanEnv({ | ||
| // MY_VAR: json<{ foo: number }>({ default: { foo: 123 } }), | ||
| // }) | ||
| function json(spec) { | ||
| return (0, exports.makeValidator)(function (x) { | ||
| try { | ||
| return JSON.parse(x); | ||
| } | ||
| catch (e) { | ||
| throw new errors.EnvError("Invalid json: \"".concat(x, "\"")); | ||
| } | ||
| })(spec); | ||
| } | ||
| exports.json = json; | ||
| }); | ||
| const CONFIG_KEY = "envalid"; | ||
@@ -492,3 +28,6 @@ async function getOptions(moduleOptions) { | ||
| const nuxtModule = async function(moduleOptions) { | ||
| const options = await getOptions.call(this, moduleOptions); | ||
| const { | ||
| options, | ||
| specs | ||
| } = await getOptions.call(this, moduleOptions); | ||
| const env = { | ||
@@ -498,4 +37,4 @@ ...process.env, | ||
| }; | ||
| const cleanEnvConfig = envalid.cleanEnv(env, options.specs, options.options); | ||
| Object.keys(options.specs).forEach((key) => { | ||
| const cleanEnvConfig = envalid.cleanEnv(env, specs, options); | ||
| Object.keys(specs).forEach((key) => { | ||
| this.options.env[key] = cleanEnvConfig[key]; | ||
@@ -507,3 +46,74 @@ process.env[key] = cleanEnvConfig[key]; | ||
| exports.__moduleExports = validators; | ||
| Object.defineProperty(exports, 'EnvError', { | ||
| enumerable: true, | ||
| get: function () { | ||
| return envalid.EnvError; | ||
| } | ||
| }); | ||
| Object.defineProperty(exports, 'EnvMissingError', { | ||
| enumerable: true, | ||
| get: function () { | ||
| return envalid.EnvMissingError; | ||
| } | ||
| }); | ||
| Object.defineProperty(exports, 'bool', { | ||
| enumerable: true, | ||
| get: function () { | ||
| return envalid.bool; | ||
| } | ||
| }); | ||
| Object.defineProperty(exports, 'email', { | ||
| enumerable: true, | ||
| get: function () { | ||
| return envalid.email; | ||
| } | ||
| }); | ||
| Object.defineProperty(exports, 'host', { | ||
| enumerable: true, | ||
| get: function () { | ||
| return envalid.host; | ||
| } | ||
| }); | ||
| Object.defineProperty(exports, 'json', { | ||
| enumerable: true, | ||
| get: function () { | ||
| return envalid.json; | ||
| } | ||
| }); | ||
| Object.defineProperty(exports, 'makeValidator', { | ||
| enumerable: true, | ||
| get: function () { | ||
| return envalid.makeValidator; | ||
| } | ||
| }); | ||
| Object.defineProperty(exports, 'num', { | ||
| enumerable: true, | ||
| get: function () { | ||
| return envalid.num; | ||
| } | ||
| }); | ||
| Object.defineProperty(exports, 'port', { | ||
| enumerable: true, | ||
| get: function () { | ||
| return envalid.port; | ||
| } | ||
| }); | ||
| Object.defineProperty(exports, 'str', { | ||
| enumerable: true, | ||
| get: function () { | ||
| return envalid.str; | ||
| } | ||
| }); | ||
| Object.defineProperty(exports, 'testOnly', { | ||
| enumerable: true, | ||
| get: function () { | ||
| return envalid.testOnly; | ||
| } | ||
| }); | ||
| Object.defineProperty(exports, 'url', { | ||
| enumerable: true, | ||
| get: function () { | ||
| return envalid.url; | ||
| } | ||
| }); | ||
| exports.default = nuxtModule; |
| { | ||
| "name": "nuxt-envalid", | ||
| "version": "0.0.1", | ||
| "version": "0.0.2", | ||
| "description": "A Nuxt.js module thats validates your env variables and loads them cleaned into your application context", | ||
@@ -5,0 +5,0 @@ "keywords": [ |
New alerts
Major refactor
Supply chain riskPackage has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.
Found 1 instance in 1 package
Worsened metrics
- Total package byte prevSize
- decreased by-65.75%
9150
- Lines of code
- decreased by-71.49%
140
- Number of medium supply chain risk alerts
- increased byInfinity%
1
No dependency changes