/ var / www / html / cqt / server / node_modules / joi / lib / [ HOME SHELL ]

Name	Size	Permission	Action
types	[ DIR ]	drwxr-xr-x
annotate.js	5.09 KB	-rwxr-xr-x
base.js	30.69 KB	-rwxr-xr-x
cache.js	2.46 KB	-rwxr-xr-x
common.js	4.81 KB	-rwxr-xr-x
compile.js	7.84 KB	-rwxr-xr-x
errors.js	5.92 KB	-rwxr-xr-x
extend.js	7.34 KB	-rwxr-xr-x
index.d.ts	80.34 KB	-rw-r--r--
index.js	6.76 KB	-rwxr-xr-x
manifest.js	11.5 KB	-rwxr-xr-x
messages.js	4.16 KB	-rwxr-xr-x
modify.js	6.68 KB	-rwxr-xr-x
ref.js	9.93 KB	-rwxr-xr-x
schemas.js	7.92 KB	-rwxr-xr-x
state.js	3.39 KB	-rwxr-xr-x
template.js	10.98 KB	-rwxr-xr-x
trace.js	8.01 KB	-rwxr-xr-x
validator.js	20.54 KB	-rwxr-xr-x
values.js	5.68 KB	-rwxr-xr-x

Code Editor : extend.js

'use strict';

const { assert, clone } = require('@hapi/hoek');

const Common = require('./common');
const Messages = require('./messages');

const internals = {};

exports.type = function (from, options) {

const base = Object.getPrototypeOf(from);
    const prototype = clone(base);
    const schema = from._assign(Object.create(prototype));
    const def = Object.assign({}, options);                                 // Shallow cloned
    delete def.base;

prototype._definition = def;

const parent = base._definition || {};
    def.messages = Messages.merge(parent.messages, def.messages);
    def.properties = Object.assign({}, parent.properties, def.properties);

// Type

schema.type = def.type;

// Flags

def.flags = Object.assign({}, parent.flags, def.flags);

// Terms

const terms = Object.assign({}, parent.terms);
    if (def.terms) {
        for (const name in def.terms) {                                     // Only apply own terms
            const term = def.terms[name];
            assert(schema.$_terms[name] === undefined, 'Invalid term override for', def.type, name);
            schema.$_terms[name] = term.init;
            terms[name] = term;
        }
    }

def.terms = terms;

// Constructor arguments

if (!def.args) {
        def.args = parent.args;
    }

// Prepare

def.prepare = internals.prepare(def.prepare, parent.prepare);

// Coerce

if (def.coerce) {
        if (typeof def.coerce === 'function') {
            def.coerce = { method: def.coerce };
        }

if (def.coerce.from &&
            !Array.isArray(def.coerce.from)) {

def.coerce = { method: def.coerce.method, from: [].concat(def.coerce.from) };
        }
    }

def.coerce = internals.coerce(def.coerce, parent.coerce);

// Validate

def.validate = internals.validate(def.validate, parent.validate);

// Rules

const rules = Object.assign({}, parent.rules);
    if (def.rules) {
        for (const name in def.rules) {
            const rule = def.rules[name];
            assert(typeof rule === 'object', 'Invalid rule definition for', def.type, name);

let method = rule.method;
            if (method === undefined) {
                method = function () {

return this.$_addRule(name);
                };
            }

if (method) {
                assert(!prototype[name], 'Rule conflict in', def.type, name);
                prototype[name] = method;
            }

assert(!rules[name], 'Rule conflict in', def.type, name);
            rules[name] = rule;

if (rule.alias) {
                const aliases = [].concat(rule.alias);
                for (const alias of aliases) {
                    prototype[alias] = rule.method;
                }
            }

if (rule.args) {
                rule.argsByName = new Map();
                rule.args = rule.args.map((arg) => {

if (typeof arg === 'string') {
                        arg = { name: arg };
                    }

assert(!rule.argsByName.has(arg.name), 'Duplicated argument name', arg.name);

if (Common.isSchema(arg.assert)) {
                        arg.assert = arg.assert.strict().label(arg.name);
                    }

rule.argsByName.set(arg.name, arg);
                    return arg;
                });
            }
        }
    }

def.rules = rules;

// Modifiers

const modifiers = Object.assign({}, parent.modifiers);
    if (def.modifiers) {
        for (const name in def.modifiers) {
            assert(!prototype[name], 'Rule conflict in', def.type, name);

const modifier = def.modifiers[name];
            assert(typeof modifier === 'function', 'Invalid modifier definition for', def.type, name);

const method = function (arg) {

return this.rule({ [name]: arg });
            };

prototype[name] = method;
            modifiers[name] = modifier;
        }
    }

def.modifiers = modifiers;

// Overrides

if (def.overrides) {
        prototype._super = base;
        schema.$_super = {};                                                            // Backwards compatibility
        for (const override in def.overrides) {
            assert(base[override], 'Cannot override missing', override);
            def.overrides[override][Common.symbols.parent] = base[override];
            schema.$_super[override] = base[override].bind(schema);                     // Backwards compatibility
        }

Object.assign(prototype, def.overrides);
    }

// Casts

def.cast = Object.assign({}, parent.cast, def.cast);

// Manifest

const manifest = Object.assign({}, parent.manifest, def.manifest);
    manifest.build = internals.build(def.manifest && def.manifest.build, parent.manifest && parent.manifest.build);
    def.manifest = manifest;

// Rebuild

def.rebuild = internals.rebuild(def.rebuild, parent.rebuild);

return schema;
};

// Helpers

internals.build = function (child, parent) {

if (!child ||
        !parent) {

return child || parent;
    }

return function (obj, desc) {

return parent(child(obj, desc), desc);
    };
};

internals.coerce = function (child, parent) {

if (!child ||
        !parent) {

return child || parent;
    }

return {
        from: child.from && parent.from ? [...new Set([...child.from, ...parent.from])] : null,
        method(value, helpers) {

let coerced;
            if (!parent.from ||
                parent.from.includes(typeof value)) {

coerced = parent.method(value, helpers);
                if (coerced) {
                    if (coerced.errors ||
                        coerced.value === undefined) {

return coerced;
                    }

value = coerced.value;
                }
            }

if (!child.from ||
                child.from.includes(typeof value)) {

const own = child.method(value, helpers);
                if (own) {
                    return own;
                }
            }

return coerced;
        }
    };
};

internals.prepare = function (child, parent) {

if (!child ||
        !parent) {

return child || parent;
    }

return function (value, helpers) {

const prepared = child(value, helpers);
        if (prepared) {
            if (prepared.errors ||
                prepared.value === undefined) {

return prepared;
            }

value = prepared.value;
        }

return parent(value, helpers) || prepared;
    };
};

internals.rebuild = function (child, parent) {

if (!child ||
        !parent) {

return child || parent;
    }

return function (schema) {

parent(schema);
        child(schema);
    };
};

internals.validate = function (child, parent) {

if (!child ||
        !parent) {

return child || parent;
    }

return function (value, helpers) {

const result = parent(value, helpers);
        if (result) {
            if (result.errors &&
                (!Array.isArray(result.errors) || result.errors.length)) {

return result;
            }

value = result.value;
        }

return child(value, helpers) || result;
    };
};

Urban Research Lab

Urban Research Lab

The Urban Research Lab (URL) at IIIT-Delhi was established in 2020, during a time when the pandemic brought the complexities of urban life more visible than ever. What started as an initiative by faculty and students has grown into a collaborative space for critically exploring and reimagining the urban questions through research, dialogue, and interdisciplinary engagement.