wikibase-edit/dist/src/lib/entity/build_claim.js

Edit Wikibase from NodeJS

import { entityEditBuilders as builders } from '../claim/builders.js';
import { buildReferenceFactory, buildPropSnaksFactory } from '../claim/snak.js';
import { hasSpecialSnaktype } from '../claim/special_snaktype.js';
import { newError } from '../error.js';
import { normalizeDatatype } from '../properties/datatypes_to_builder_datatypes.js';
import { isString, isNumber, isPlainObject, mapValues, forceArray } from '../utils.js';
import { validateGuid, validateRank, validateSnakValue } from '../validate.js';
export function buildClaim(property, properties, claimData, instance) {
    const datatype = properties[property];
    const builderDatatype = normalizeDatatype(datatype);
    const builder = builders[builderDatatype];
    const params = { properties, datatype, property, claimData, builder, instance };
    if (isString(claimData) || isNumber(claimData)) {
        return simpleClaimBuilder(params);
    }
    else {
        if (!isPlainObject(claimData))
            throw newError('invalid claim data', { property, claimData });
        return fullClaimBuilder(params);
    }
}
function simpleClaimBuilder(params) {
    const { property, datatype, claimData: value, builder, instance } = params;
    validateSnakValue(property, datatype, value);
    return builder(property, value, instance);
}
function fullClaimBuilder(params) {
    const { properties, datatype, property, claimData, builder, instance } = params;
    validateClaimParameters(claimData);
    let { id, value, snaktype, rank, qualifiers, references, remove, reconciliation } = claimData;
    if (remove === true) {
        if (!(id || reconciliation))
            throw newError("can't remove a claim without an id or reconciliation settings", claimData);
        if (id)
            return { id, remove: true };
    }
    let claim;
    if (value?.snaktype) {
        claimData.snaktype = snaktype = value.snaktype;
    }
    if (hasSpecialSnaktype(claimData)) {
        claim = builders.specialSnaktype(property, snaktype);
    }
    else {
        // In case of a rich value (monolingual text, quantity, globe coordinate, or time)
        if (value == null && (claimData.text || claimData.amount || claimData.latitude || claimData.time)) {
            value = claimData;
        }
        validateSnakValue(property, datatype, value);
        claim = builder(property, value, instance);
    }
    if (id) {
        validateGuid(id);
        claim.id = id;
    }
    if (rank) {
        validateRank(rank);
        claim.rank = rank;
    }
    if (qualifiers) {
        claim.qualifiers = mapValues(qualifiers, buildPropSnaksFactory(properties, instance));
    }
    if (references) {
        claim.references = forceArray(references).map(buildReferenceFactory(properties, instance));
    }
    if (reconciliation)
        claim.reconciliation = reconciliation;
    if (remove)
        claim.remove = remove;
    return claim;
}
const validClaimParameters = [
    'id',
    'type',
    'value',
    'snaktype',
    'rank',
    'qualifiers',
    'references',
    'remove',
    'reconciliation',
    'text',
    'language',
    'amount',
    'lowerBound',
    'upperBound',
    'unit',
    'latitude',
    'longitude',
    'precision',
    'globe',
    'altitude',
    'time',
    'timezone',
    'before',
    'after',
    'precision',
    'calendarmodel',
];
const validClaimParametersSet = new Set(validClaimParameters);
function validateClaimParameters(claimData) {
    for (const key in claimData) {
        if (!validClaimParametersSet.has(key)) {
            throw newError(`invalid claim parameter: ${key}`, { claimData, validClaimParameters });
        }
    }
}
//# sourceMappingURL=build_claim.js.map