@depup/joi 18.1.1-depup.0

package/lib/values.js

@@ -0,0 +1,262 @@
+'use strict';
+
+const { assert, deepEqual } = require('@hapi/hoek');
+
+const Common = require('./common');
+
+
+const internals = {};
+
+
+module.exports = internals.Values = class {
+
+    constructor(values, refs) {
+
+        this._values = new Set(values);
+        this._refs = new Set(refs);
+        this._lowercase = internals.lowercases(values);
+
+        this._override = false;
+    }
+
+    get length() {
+
+        return this._values.size + this._refs.size;
+    }
+
+    add(value, refs) {
+
+        // Reference
+
+        if (Common.isResolvable(value)) {
+            if (!this._refs.has(value)) {
+                this._refs.add(value);
+
+                if (refs) {                     // Skipped in a merge
+                    refs.register(value);
+                }
+            }
+
+            return;
+        }
+
+        // Value
+
+        if (!this.has(value, null, null, false)) {
+            this._values.add(value);
+
+            if (typeof value === 'string') {
+                this._lowercase.set(value.toLowerCase(), value);
+            }
+        }
+    }
+
+    static merge(target, source, remove) {
+
+        target = target || new internals.Values();
+
+        if (source) {
+            if (source._override) {
+                return source.clone();
+            }
+
+            for (const item of [...source._values, ...source._refs]) {
+                target.add(item);
+            }
+        }
+
+        if (remove) {
+            for (const item of [...remove._values, ...remove._refs]) {
+                target.remove(item);
+            }
+        }
+
+        return target.length ? target : null;
+    }
+
+    remove(value) {
+
+        // Reference
+
+        if (Common.isResolvable(value)) {
+            this._refs.delete(value);
+            return;
+        }
+
+        // Value
+
+        this._values.delete(value);
+
+        if (typeof value === 'string') {
+            this._lowercase.delete(value.toLowerCase());
+        }
+    }
+
+    has(value, state, prefs, insensitive) {
+
+        return !!this.get(value, state, prefs, insensitive);
+    }
+
+    get(value, state, prefs, insensitive) {
+
+        if (!this.length) {
+            return false;
+        }
+
+        // Simple match
+
+        if (this._values.has(value)) {
+            return { value };
+        }
+
+        // Case insensitive string match
+
+        if (typeof value === 'string' &&
+            value &&
+            insensitive) {
+
+            const found = this._lowercase.get(value.toLowerCase());
+            if (found) {
+                return { value: found };
+            }
+        }
+
+        if (!this._refs.size &&
+            typeof value !== 'object') {
+
+            return false;
+        }
+
+        // Objects
+
+        if (typeof value === 'object') {
+            for (const item of this._values) {
+                if (deepEqual(item, value)) {
+                    return { value: item };
+                }
+            }
+        }
+
+        // References
+
+        if (state) {
+            for (const ref of this._refs) {
+                const resolved = ref.resolve(value, state, prefs, null, { in: true });
+                if (resolved === undefined) {
+                    continue;
+                }
+
+                const items = !ref.in || typeof resolved !== 'object'
+                    ? [resolved]
+                    : Array.isArray(resolved) ? resolved : Object.keys(resolved);
+
+                for (const item of items) {
+                    if (typeof item !== typeof value) {
+                        continue;
+                    }
+
+                    if (insensitive &&
+                        value &&
+                        typeof value === 'string') {
+
+                        if (item.toLowerCase() === value.toLowerCase()) {
+                            return { value: item, ref };
+                        }
+                    }
+                    else {
+                        if (deepEqual(item, value)) {
+                            return { value: item, ref };
+                        }
+                    }
+                }
+            }
+        }
+
+        return false;
+    }
+
+    override() {
+
+        this._override = true;
+    }
+
+    values(options) {
+
+        if (options &&
+            options.display) {
+
+            const values = [];
+
+            for (const item of [...this._values, ...this._refs]) {
+                if (item !== undefined) {
+                    values.push(item);
+                }
+            }
+
+            return values;
+        }
+
+        return Array.from([...this._values, ...this._refs]);
+    }
+
+    clone() {
+
+        const set = new internals.Values(this._values, this._refs);
+        set._override = this._override;
+        return set;
+    }
+
+    concat(source) {
+
+        assert(!source._override, 'Cannot concat override set of values');
+
+        const set = new internals.Values([...this._values, ...source._values], [...this._refs, ...source._refs]);
+        set._override = this._override;
+        return set;
+    }
+
+    describe() {
+
+        const normalized = [];
+
+        if (this._override) {
+            normalized.push({ override: true });
+        }
+
+        for (const value of this._values.values()) {
+            normalized.push(value && typeof value === 'object' ? { value } : value);
+        }
+
+        for (const value of this._refs.values()) {
+            normalized.push(value.describe());
+        }
+
+        return normalized;
+    }
+};
+
+
+internals.Values.prototype[Common.symbols.values] = true;
+
+
+// Aliases
+
+internals.Values.prototype.slice = internals.Values.prototype.clone;
+
+
+// Helpers
+
+internals.lowercases = function (from) {
+
+    const map = new Map();
+
+    if (from) {
+        for (const value of from) {
+            if (typeof value === 'string') {
+                map.set(value.toLowerCase(), value);
+            }
+        }
+    }
+
+    return map;
+};

package/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "@depup/joi",
+  "description": "Object schema validation (with updated dependencies)",
+  "version": "18.1.1-depup.0",
+  "repository": {
+    "url": "git://github.com/hapijs/joi.git",
+    "type": "git"
+  },
+  "engines": {
+    "node": ">= 20"
+  },
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "browser": "dist/joi-browser.min.js",
+  "files": [
+    "lib/**/*",
+    "dist/*",
+    "changes.json",
+    "README.md"
+  ],
+  "keywords": [
+    "joi",
+    "depup",
+    "updated-dependencies",
+    "security",
+    "latest",
+    "patched",
+    "schema",
+    "validation"
+  ],
+  "dependencies": {
+    "@hapi/address": "^5.1.1",
+    "@hapi/formula": "^3.0.2",
+    "@hapi/hoek": "^11.0.7",
+    "@hapi/pinpoint": "^2.0.1",
+    "@hapi/tlds": "^1.1.6",
+    "@hapi/topo": "^6.0.2",
+    "@standard-schema/spec": "^1.1.0"
+  },
+  "devDependencies": {
+    "@hapi/bourne": "^3.0.0",
+    "@hapi/code": "^9.0.3",
+    "@hapi/eslint-plugin": "^7.0.0",
+    "@hapi/joi-legacy-test": "npm:@hapi/joi@15.x.x",
+    "@hapi/lab": "^26.0.0",
+    "@types/node": "^20.17.47",
+    "ajv": "^8.18.0",
+    "typescript": "^5.8.3"
+  },
+  "scripts": {
+    "test": "lab -t 100 -a @hapi/code -L -Y",
+    "test-cov-html": "lab -r html -o coverage.html -a @hapi/code"
+  },
+  "license": "BSD-3-Clause",
+  "depup": {
+    "changes": {
+      "@hapi/tlds": {
+        "from": "^1.1.1",
+        "to": "^1.1.6"
+      }
+    },
+    "depsUpdated": 1,
+    "originalPackage": "joi",
+    "originalVersion": "18.1.1",
+    "processedAt": "2026-03-23T20:18:46.146Z",
+    "smokeTest": "passed"
+  }
+}