@fin.cx/opendata 4.3.1 → 4.4.0

package/.smartconfig.json

@@ -5,7 +5,7 @@
       "githost": "gitlab.com",
       "gitscope": "fin.cx",
       "gitrepo": "opendata",
-      "description": "Open business and financial data for TypeScript: register lookups on the German register portal (handelsregister.de) without storage, the statutory public holidays of the German federal states, the base rate of § 247 BGB, and stock and crypto prices and fundamentals from several providers.",
+      "description": "Open business and financial data for TypeScript: register lookups on the German register portal (handelsregister.de) without storage, the statutory public holidays of the German federal states, the base rate of § 247 BGB, the German consumer price index with the arithmetic of index clauses, and stock and crypto prices and fundamentals from several providers.",
       "npmPackagename": "@fin.cx/opendata",
       "license": "MIT",
       "projectDomain": "fin.cx",
@@ -27,7 +27,10 @@
         "Feiertage",
         "working days",
         "Basiszinssatz",
-        "base rate"
+        "base rate",
+        "consumer price index",
+        "Verbraucherpreisindex",
+        "index clause"
       ]
     },
     "release": {

package/dist_ts/00_commitinfo_data.js

@@ -3,7 +3,7 @@
  */
 export const commitinfo = {
     name: '@fin.cx/opendata',
-    version: '4.3.1',
-    description: 'Open business and financial data for TypeScript: register lookups on the German register portal (handelsregister.de) without storage, the statutory public holidays of the German federal states, the base rate of § 247 BGB, and stock and crypto prices and fundamentals from several providers.'
+    version: '4.4.0',
+    description: 'Open business and financial data for TypeScript: register lookups on the German register portal (handelsregister.de) without storage, the statutory public holidays of the German federal states, the base rate of § 247 BGB, the German consumer price index with the arithmetic of index clauses, and stock and crypto prices and fundamentals from several providers.'
 };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSxrQkFBa0I7SUFDeEIsT0FBTyxFQUFFLE9BQU87SUFDaEIsV0FBVyxFQUFFLG9TQUFvUztDQUNsVCxDQUFBIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSxrQkFBa0I7SUFDeEIsT0FBTyxFQUFFLE9BQU87SUFDaEIsV0FBVyxFQUFFLDBXQUEwVztDQUN4WCxDQUFBIn0=

package/dist_ts/cpi/classes.bundesbankcpiclient.d.ts

@@ -0,0 +1,25 @@
+import type { ICpiAnnualInput, ICpiClientOptions, ICpiMonthlyInput, ICpiReading, ICpiSeries } from './interfaces.js';
+/**
+ * The Verbraucherpreisindex für Deutschland (overall index, unadjusted) of the Statistisches Bundesamt as
+ * the Deutsche Bundesbank republishes it in its time series API (`bundesbankCpiBaseUrl`), monthly and as
+ * annual averages. Each answer names its base, and the values the Bundesbank marks as its own estimate
+ * (the latest month at times) are kept apart from the published ones. Nothing is kept: each answer goes
+ * to the caller with the source note to show and the answer as it arrived.
+ */
+export declare class BundesbankCpiClient {
+    private readonly options;
+    private readonly baseUrl;
+    constructor(options?: ICpiClientOptions);
+    /** The months from `from` to `to`, both included, or to the latest one when `to` is left out. */
+    getMonthly(inputArg: ICpiMonthlyInput): Promise<ICpiSeries>;
+    /** The annual averages from `from` to `to`, both included, or to the latest one when `to` is left out. */
+    getAnnual(inputArg: ICpiAnnualInput): Promise<ICpiSeries>;
+    /**
+     * The published value of one month. A month with only the Bundesbank's estimate, or with nothing yet,
+     * ends in `not_published`, the estimate in the error where there is one.
+     */
+    getMonth(monthArg: string, optionsArg?: {
+        signal?: AbortSignal;
+    }): Promise<ICpiReading>;
+    private getSeries;
+}

package/dist_ts/cpi/classes.bundesbankcpiclient.js

@@ -0,0 +1,250 @@
+import { CpiError } from './classes.cpierror.js';
+import { bundesbankCpiBaseUrl, bundesbankVpiAnnualKey, bundesbankVpiFirstMonth, bundesbankVpiFirstYear, bundesbankVpiMonthlyKey, destatisLicence, } from './constants.js';
+import { parseDecimal } from './decimal.js';
+import { frequencyOf } from './indexmath.js';
+import { getText, timeoutOf } from './request.js';
+/**
+ * The columns of the API's SDMX-CSV answer this client reads. The API leaves out a column that is empty
+ * in every row: `OBS_STATUS` appears only where a value carries a status.
+ */
+const COLUMNS = ['BBK_STD_FREQ', 'TIME_PERIOD', 'OBS_VALUE', 'BBK_DECIMALS', 'BBK_ID', 'BBK_UNIT', 'BBK_TITLE'];
+const STATUS_COLUMN = 'OBS_STATUS';
+/** The key of the overall index for Germany on one base, as the answer names it. */
+const SERIES_KEY = /^BBDP1\.([MA])\.DE\.N\.VPI\.C\.A00000\.I(\d{2})\.A$/u;
+const UNIT = /^(\d{4})=100$/u;
+const FREQUENCY_CODES = { monthly: 'M', annual: 'A' };
+/** What the API's `OBS_STATUS` says about a value; any other flag is not read. */
+const STATUSES = { '': 'final', E: 'estimated' };
+/** One line of semicolon-separated values; a field in double quotes may hold separators and doubled quotes. */
+const splitLine = (lineArg) => {
+    const fields = [];
+    let field = '';
+    let quoted = false;
+    for (let position = 0; position < lineArg.length; position++) {
+        const character = lineArg[position];
+        if (quoted) {
+            if (character === '"' && lineArg[position + 1] === '"') {
+                field += '"';
+                position++;
+            }
+            else if (character === '"') {
+                quoted = false;
+            }
+            else {
+                field += character;
+            }
+        }
+        else if (character === '"' && field === '') {
+            quoted = true;
+        }
+        else if (character === ';') {
+            fields.push(field);
+            field = '';
+        }
+        else {
+            field += character;
+        }
+    }
+    if (quoted) {
+        return undefined;
+    }
+    fields.push(field);
+    return fields;
+};
+/**
+ * The Verbraucherpreisindex für Deutschland (overall index, unadjusted) of the Statistisches Bundesamt as
+ * the Deutsche Bundesbank republishes it in its time series API (`bundesbankCpiBaseUrl`), monthly and as
+ * annual averages. Each answer names its base, and the values the Bundesbank marks as its own estimate
+ * (the latest month at times) are kept apart from the published ones. Nothing is kept: each answer goes
+ * to the caller with the source note to show and the answer as it arrived.
+ */
+export class BundesbankCpiClient {
+    options;
+    baseUrl;
+    constructor(options = {}) {
+        this.options = options;
+        timeoutOf(options);
+        this.baseUrl = (options.baseUrl ?? bundesbankCpiBaseUrl).replace(/\/?$/u, '/');
+    }
+    /** The months from `from` to `to`, both included, or to the latest one when `to` is left out. */
+    async getMonthly(inputArg) {
+        return this.getSeries({ frequency: 'monthly', from: inputArg.from, ...(inputArg.to !== undefined ? { to: inputArg.to } : {}) }, inputArg.signal);
+    }
+    /** The annual averages from `from` to `to`, both included, or to the latest one when `to` is left out. */
+    async getAnnual(inputArg) {
+        return this.getSeries({ frequency: 'annual', from: inputArg.from, ...(inputArg.to !== undefined ? { to: inputArg.to } : {}) }, inputArg.signal);
+    }
+    /**
+     * The published value of one month. A month with only the Bundesbank's estimate, or with nothing yet,
+     * ends in `not_published`, the estimate in the error where there is one.
+     */
+    async getMonth(monthArg, optionsArg = {}) {
+        const series = await this.getSeries({ frequency: 'monthly', from: monthArg, to: monthArg }, optionsArg.signal);
+        const value = series.values[0];
+        if (!value) {
+            const estimate = series.estimates[0];
+            const message = estimate
+                ? `the index for ${monthArg} is not published yet; the Bundesbank gives only its own estimate (${estimate.value}).`
+                : `the index for ${monthArg} is not published yet.`;
+            throw new CpiError('not_published', message, {
+                service: 'bundesbank',
+                httpStatus: series.answer.httpStatus,
+                answer: series.answer,
+                period: monthArg,
+                ...(estimate ? { estimate } : {}),
+            });
+        }
+        return { ...value, source: series.source, answer: series.answer };
+    }
+    async getSeries(rangeArg, signalArg) {
+        checkRange(rangeArg);
+        const key = rangeArg.frequency === 'monthly' ? bundesbankVpiMonthlyKey : bundesbankVpiAnnualKey;
+        const uri = `${this.baseUrl}${key}?startPeriod=${rangeArg.from}${rangeArg.to !== undefined ? `&endPeriod=${rangeArg.to}` : ''}`;
+        const answer = await getText(this.options, uri, signalArg);
+        const refused = (codeArg, messageArg) => new CpiError(codeArg, messageArg, { service: 'bundesbank', httpStatus: answer.httpStatus, answer });
+        if (answer.httpStatus === 404) {
+            throw refused('series_withdrawn', `the Bundesbank has no series ${key}: it answered 404.`);
+        }
+        if (answer.httpStatus === 429) {
+            throw refused('busy', 'the Bundesbank refused the request as one too many (429).');
+        }
+        if (answer.httpStatus >= 500 && answer.httpStatus <= 599) {
+            throw refused('unavailable', `the Bundesbank cannot answer now (${answer.httpStatus}).`);
+        }
+        if (answer.httpStatus !== 200) {
+            throw refused('unexpected_answer', `the Bundesbank answered ${answer.httpStatus}.`);
+        }
+        const read = readAnswer(answer.text, rangeArg, (messageArg) => refused('unexpected_answer', messageArg));
+        if (!read) {
+            throw new CpiError('not_published', `the Bundesbank has no value from ${rangeArg.from}${rangeArg.to !== undefined ? ` to ${rangeArg.to}` : ' on'} yet.`, {
+                service: 'bundesbank',
+                httpStatus: answer.httpStatus,
+                answer,
+                period: rangeArg.from,
+            });
+        }
+        return {
+            index: 'de-vpi',
+            frequency: rangeArg.frequency,
+            base: read.base,
+            baseYear: read.baseYear,
+            values: read.values,
+            estimates: read.estimates,
+            source: sourceNoteOf(read, uri),
+            answer,
+        };
+    }
+}
+/** A range of the series' periods, or the reason it is none. */
+const checkRange = (rangeArg) => {
+    const written = rangeArg.frequency === 'monthly' ? 'YYYY-MM' : 'YYYY';
+    for (const period of [rangeArg.from, rangeArg.to]) {
+        if (period !== undefined && frequencyOf(period) !== rangeArg.frequency) {
+            throw new CpiError('invalid_input', `${JSON.stringify(period)} is no period written ${written}.`);
+        }
+    }
+    if (rangeArg.to !== undefined && rangeArg.to < rangeArg.from) {
+        throw new CpiError('invalid_input', `the range ends (${rangeArg.to}) before it begins (${rangeArg.from}).`);
+    }
+    const first = rangeArg.frequency === 'monthly' ? bundesbankVpiFirstMonth : bundesbankVpiFirstYear;
+    if (rangeArg.from < first) {
+        throw new CpiError('before_first_period', `${rangeArg.from} lies before ${first}, the first period of the series.`, { period: rangeArg.from });
+    }
+};
+/**
+ * The values of an SDMX-CSV answer, or `undefined` where it holds none. An answer is read only where every
+ * row is of the series and the frequency asked for, of one key and one base, inside the range asked for,
+ * once per period, with a value of the digits the answer states and a status this client knows.
+ */
+const readAnswer = (textArg, rangeArg, unreadableArg) => {
+    const lines = textArg.replace(/^/u, '').split(/\r?\n/u).filter((lineArg) => lineArg !== '');
+    const header = lines[0] === undefined ? undefined : splitLine(lines[0]);
+    if (!header || header[0] !== 'DATAFLOW') {
+        throw unreadableArg('the answer is no SDMX-CSV of the Bundesbank.');
+    }
+    const rows = lines.slice(1);
+    if (rows.length === 0) {
+        return undefined;
+    }
+    const missing = COLUMNS.filter((columnArg) => !header.includes(columnArg));
+    if (missing.length > 0) {
+        throw unreadableArg(`the answer has no column ${missing.join(', ')}.`);
+    }
+    const at = (fieldsArg, columnArg) => {
+        const position = header.indexOf(columnArg);
+        return position < 0 ? '' : fieldsArg[position] ?? '';
+    };
+    const values = [];
+    const estimates = [];
+    const periods = new Set();
+    let key;
+    let title = '';
+    let base = '';
+    let baseYear = 0;
+    for (const row of rows) {
+        const fields = splitLine(row);
+        if (!fields || fields.length !== header.length) {
+            throw unreadableArg(`a row is not of the answer's columns: ${row}`);
+        }
+        const rowKey = at(fields, 'BBK_ID');
+        const keyMatch = SERIES_KEY.exec(rowKey);
+        const unitMatch = UNIT.exec(at(fields, 'BBK_UNIT'));
+        const frequencyCode = FREQUENCY_CODES[rangeArg.frequency];
+        if (!keyMatch || keyMatch[1] !== frequencyCode || at(fields, 'BBK_STD_FREQ') !== frequencyCode) {
+            throw unreadableArg(`${JSON.stringify(rowKey)} is not the ${rangeArg.frequency} series of the overall index for Germany.`);
+        }
+        if (!unitMatch || unitMatch[1].slice(2) !== keyMatch[2]) {
+            throw unreadableArg(`${JSON.stringify(at(fields, 'BBK_UNIT'))} is no base of the series ${rowKey}.`);
+        }
+        if (key !== undefined && key !== rowKey) {
+            throw unreadableArg(`the answer holds more than one series or base: ${key} and ${rowKey}.`);
+        }
+        key = rowKey;
+        title = at(fields, 'BBK_TITLE');
+        base = unitMatch[0];
+        baseYear = Number(unitMatch[1]);
+        const period = at(fields, 'TIME_PERIOD');
+        if (frequencyOf(period) !== rangeArg.frequency || period < rangeArg.from || (rangeArg.to !== undefined && period > rangeArg.to)) {
+            throw unreadableArg(`${JSON.stringify(period)} is not a period asked for.`);
+        }
+        if (periods.has(period)) {
+            throw unreadableArg(`${period} is answered twice.`);
+        }
+        periods.add(period);
+        const flag = at(fields, STATUS_COLUMN);
+        if (!Object.hasOwn(STATUSES, flag)) {
+            throw unreadableArg(`${JSON.stringify(flag)} is no status this client knows, for ${period}.`);
+        }
+        const status = STATUSES[flag];
+        const written = at(fields, 'OBS_VALUE');
+        if (written === '' || written === 'NaN') {
+            // a period without a value has no observation
+            continue;
+        }
+        const decimals = Number(at(fields, 'BBK_DECIMALS'));
+        const decimal = parseDecimal(written);
+        if (!Number.isSafeInteger(decimals) || decimals < 0 || decimals > 6 || !decimal || decimal.units <= 0n || decimal.scale > decimals) {
+            throw unreadableArg(`${JSON.stringify(written)} is no index value of ${at(fields, 'BBK_DECIMALS')} decimals, for ${period}.`);
+        }
+        const value = decimal.scale === decimals ? written : `${written}${decimal.scale === 0 ? '.' : ''}${'0'.repeat(decimals - decimal.scale)}`;
+        (status === 'final' ? values : estimates).push({ index: 'de-vpi', period, value, base, status });
+    }
+    if (key === undefined || values.length + estimates.length === 0) {
+        return undefined;
+    }
+    const byPeriod = (leftArg, rightArg) => leftArg.period.localeCompare(rightArg.period);
+    return { values: values.sort(byPeriod), estimates: estimates.sort(byPeriod), base, baseYear, key, title };
+};
+const sourceNoteOf = (readArg, uriArg) => ({
+    source: 'bundesbank',
+    provider: 'Deutsche Bundesbank',
+    dataOrigin: 'Statistisches Bundesamt (Destatis)',
+    title: readArg.title,
+    key: readArg.key,
+    uri: uriArg,
+    licence: destatisLicence.name,
+    licenceUri: destatisLicence.uri,
+    attribution: `Quelle: Deutsche Bundesbank, Zeitreihe ${readArg.key}; Daten: Statistisches Bundesamt (Destatis), ` +
+        `Verbraucherpreisindex für Deutschland, ${readArg.base}; ${destatisLicence.name} (${destatisLicence.uri}); ${uriArg}`,
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.bundesbankcpiclient.js","sourceRoot":"","sources":["../../ts/cpi/classes.bundesbankcpiclient.ts"],"names":[],"mappings":"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"}

package/dist_ts/cpi/classes.cpierror.d.ts

@@ -0,0 +1,44 @@
+import type { ICpiServiceAnswer, ICpiValue, TCpiPeriod } from './interfaces.js';
+/**
+ * Why no index value or no result was given:
+ * - `invalid_input`: a period, a value, a percentage or an amount that is not one, or a range that ends
+ *   before it begins;
+ * - `before_first_period`: a period before the first one the series holds;
+ * - `not_published`: no published value for the period yet: nothing at all, or only an estimate
+ *   (`estimate`); a calculation given an estimate refuses it the same way;
+ * - `base_mismatch`: values of different bases, indices or frequencies, which are never compared;
+ * - `series_withdrawn`: the source no longer has the series asked for (HTTP 404), as happens to a
+ *   series key of an old base after the base year changed;
+ * - `busy`: the source refuses for too many requests (HTTP 429);
+ * - `unavailable`: the source cannot answer now (HTTP 5xx);
+ * - `unreachable`: no answer arrived: the name, the connection or TLS failed;
+ * - `timeout`: the answer did not arrive within the client's time;
+ * - `aborted`: the caller's signal ended the request;
+ * - `unexpected_answer`: an answer this client cannot read: another status, a missing column, a value or
+ *   a flag it does not know, a period it did not ask for, or more than one series or base.
+ */
+export type TCpiErrorCode = 'invalid_input' | 'before_first_period' | 'not_published' | 'base_mismatch' | 'series_withdrawn' | 'busy' | 'unavailable' | 'unreachable' | 'timeout' | 'aborted' | 'unexpected_answer';
+export interface ICpiErrorDetails {
+    /** the source asked, where a request was sent */
+    service?: 'bundesbank';
+    /** the HTTP status of the answer, where one arrived */
+    httpStatus?: number;
+    /** the answer as it arrived, where one did */
+    answer?: ICpiServiceAnswer;
+    /** the period the refusal is about */
+    period?: TCpiPeriod;
+    /** the estimate the source gave for that period, where it gave one (`not_published`) */
+    estimate?: ICpiValue;
+}
+/** The typed error of `@fin.cx/opendata/cpi`. */
+export declare class CpiError extends Error {
+    readonly code: TCpiErrorCode;
+    readonly service?: ICpiErrorDetails['service'];
+    readonly httpStatus?: number;
+    readonly answer?: ICpiServiceAnswer;
+    readonly period?: TCpiPeriod;
+    readonly estimate?: ICpiValue;
+    constructor(code: TCpiErrorCode, message: string, detailsArg?: ICpiErrorDetails, options?: {
+        cause?: unknown;
+    });
+}

package/dist_ts/cpi/classes.cpierror.js

@@ -0,0 +1,30 @@
+/** The typed error of `@fin.cx/opendata/cpi`. */
+export class CpiError extends Error {
+    code;
+    service;
+    httpStatus;
+    answer;
+    period;
+    estimate;
+    constructor(code, message, detailsArg = {}, options) {
+        super(message, options);
+        this.name = 'CpiError';
+        this.code = code;
+        if (detailsArg.service !== undefined) {
+            this.service = detailsArg.service;
+        }
+        if (detailsArg.httpStatus !== undefined) {
+            this.httpStatus = detailsArg.httpStatus;
+        }
+        if (detailsArg.answer !== undefined) {
+            this.answer = detailsArg.answer;
+        }
+        if (detailsArg.period !== undefined) {
+            this.period = detailsArg.period;
+        }
+        if (detailsArg.estimate !== undefined) {
+            this.estimate = detailsArg.estimate;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xhc3Nlcy5jcGllcnJvci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3RzL2NwaS9jbGFzc2VzLmNwaWVycm9yLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQThDQSxpREFBaUQ7QUFDakQsTUFBTSxPQUFPLFFBQVMsU0FBUSxLQUFLO0lBQ2pCLElBQUksQ0FBZ0I7SUFDcEIsT0FBTyxDQUErQjtJQUN0QyxVQUFVLENBQVU7SUFDcEIsTUFBTSxDQUFxQjtJQUMzQixNQUFNLENBQWM7SUFDcEIsUUFBUSxDQUFhO0lBRXJDLFlBQVksSUFBbUIsRUFBRSxPQUFlLEVBQUUsYUFBK0IsRUFBRSxFQUFFLE9BQTZCO1FBQ2hILEtBQUssQ0FBQyxPQUFPLEVBQUUsT0FBTyxDQUFDLENBQUM7UUFDeEIsSUFBSSxDQUFDLElBQUksR0FBRyxVQUFVLENBQUM7UUFDdkIsSUFBSSxDQUFDLElBQUksR0FBRyxJQUFJLENBQUM7UUFDakIsSUFBSSxVQUFVLENBQUMsT0FBTyxLQUFLLFNBQVMsRUFBRSxDQUFDO1lBQ3JDLElBQUksQ0FBQyxPQUFPLEdBQUcsVUFBVSxDQUFDLE9BQU8sQ0FBQztRQUNwQyxDQUFDO1FBQ0QsSUFBSSxVQUFVLENBQUMsVUFBVSxLQUFLLFNBQVMsRUFBRSxDQUFDO1lBQ3hDLElBQUksQ0FBQyxVQUFVLEdBQUcsVUFBVSxDQUFDLFVBQVUsQ0FBQztRQUMxQyxDQUFDO1FBQ0QsSUFBSSxVQUFVLENBQUMsTUFBTSxLQUFLLFNBQVMsRUFBRSxDQUFDO1lBQ3BDLElBQUksQ0FBQyxNQUFNLEdBQUcsVUFBVSxDQUFDLE1BQU0sQ0FBQztRQUNsQyxDQUFDO1FBQ0QsSUFBSSxVQUFVLENBQUMsTUFBTSxLQUFLLFNBQVMsRUFBRSxDQUFDO1lBQ3BDLElBQUksQ0FBQyxNQUFNLEdBQUcsVUFBVSxDQUFDLE1BQU0sQ0FBQztRQUNsQyxDQUFDO1FBQ0QsSUFBSSxVQUFVLENBQUMsUUFBUSxLQUFLLFNBQVMsRUFBRSxDQUFDO1lBQ3RDLElBQUksQ0FBQyxRQUFRLEdBQUcsVUFBVSxDQUFDLFFBQVEsQ0FBQztRQUN0QyxDQUFDO0lBQ0gsQ0FBQztDQUNGIn0=

package/dist_ts/cpi/constants.d.ts

@@ -0,0 +1,24 @@
+/**
+ * The Deutsche Bundesbank's time series API (SDMX REST), dataflow `BBDP1`, where the Bundesbank
+ * republishes the Verbraucherpreisindex für Deutschland of the Statistisches Bundesamt ("Quelle:
+ * Statistisches Bundesamt, Wiesbaden."). Read on 2026-10-05; it answers without registration.
+ */
+export declare const bundesbankCpiBaseUrl = "https://api.statistiken.bundesbank.de/rest/data/BBDP1/";
+/**
+ * The series keys of the overall index for Germany, monthly and annual average, unadjusted. The base
+ * dimension is left open (`..A`): the answer names the current base (`BBDP1.M.DE.N.VPI.C.A00000.I20.A`,
+ * 2020=100), and when the Statistisches Bundesamt changes the base year the Bundesbank withdraws the
+ * key of the old one (the `I15` key of 2015=100 answers 404).
+ */
+export declare const bundesbankVpiMonthlyKey = "M.DE.N.VPI.C.A00000..A";
+export declare const bundesbankVpiAnnualKey = "A.DE.N.VPI.C.A00000..A";
+/** The first month and year of the series (January 1991, the first one the API answers). */
+export declare const bundesbankVpiFirstMonth = "1991-01";
+export declare const bundesbankVpiFirstYear = "1991";
+/** The licence under which the Statistisches Bundesamt publishes its figures. */
+export declare const destatisLicence: {
+    readonly name: "Datenlizenz Deutschland – Namensnennung – Version 2.0";
+    readonly uri: "https://www.govdata.de/dl-de/by-2-0";
+};
+/** How long one request may take by default, the answer included. */
+export declare const defaultCpiTimeoutMs = 30000;

package/dist_ts/cpi/constants.js

@@ -0,0 +1,25 @@
+/**
+ * The Deutsche Bundesbank's time series API (SDMX REST), dataflow `BBDP1`, where the Bundesbank
+ * republishes the Verbraucherpreisindex für Deutschland of the Statistisches Bundesamt ("Quelle:
+ * Statistisches Bundesamt, Wiesbaden."). Read on 2026-10-05; it answers without registration.
+ */
+export const bundesbankCpiBaseUrl = 'https://api.statistiken.bundesbank.de/rest/data/BBDP1/';
+/**
+ * The series keys of the overall index for Germany, monthly and annual average, unadjusted. The base
+ * dimension is left open (`..A`): the answer names the current base (`BBDP1.M.DE.N.VPI.C.A00000.I20.A`,
+ * 2020=100), and when the Statistisches Bundesamt changes the base year the Bundesbank withdraws the
+ * key of the old one (the `I15` key of 2015=100 answers 404).
+ */
+export const bundesbankVpiMonthlyKey = 'M.DE.N.VPI.C.A00000..A';
+export const bundesbankVpiAnnualKey = 'A.DE.N.VPI.C.A00000..A';
+/** The first month and year of the series (January 1991, the first one the API answers). */
+export const bundesbankVpiFirstMonth = '1991-01';
+export const bundesbankVpiFirstYear = '1991';
+/** The licence under which the Statistisches Bundesamt publishes its figures. */
+export const destatisLicence = {
+    name: 'Datenlizenz Deutschland – Namensnennung – Version 2.0',
+    uri: 'https://www.govdata.de/dl-de/by-2-0',
+};
+/** How long one request may take by default, the answer included. */
+export const defaultCpiTimeoutMs = 30_000;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uc3RhbnRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vdHMvY3BpL2NvbnN0YW50cy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7OztHQUlHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sb0JBQW9CLEdBQUcsd0RBQXdELENBQUM7QUFFN0Y7Ozs7O0dBS0c7QUFDSCxNQUFNLENBQUMsTUFBTSx1QkFBdUIsR0FBRyx3QkFBd0IsQ0FBQztBQUNoRSxNQUFNLENBQUMsTUFBTSxzQkFBc0IsR0FBRyx3QkFBd0IsQ0FBQztBQUUvRCw0RkFBNEY7QUFDNUYsTUFBTSxDQUFDLE1BQU0sdUJBQXVCLEdBQUcsU0FBUyxDQUFDO0FBQ2pELE1BQU0sQ0FBQyxNQUFNLHNCQUFzQixHQUFHLE1BQU0sQ0FBQztBQUU3QyxpRkFBaUY7QUFDakYsTUFBTSxDQUFDLE1BQU0sZUFBZSxHQUFHO0lBQzdCLElBQUksRUFBRSx1REFBdUQ7SUFDN0QsR0FBRyxFQUFFLHFDQUFxQztDQUNsQyxDQUFDO0FBRVgscUVBQXFFO0FBQ3JFLE1BQU0sQ0FBQyxNQUFNLG1CQUFtQixHQUFHLE1BQU0sQ0FBQyJ9

package/dist_ts/cpi/decimal.d.ts

@@ -0,0 +1,13 @@
+/** A non-negative decimal as integer units of 10^-scale: `'113.5'` is 1135 at scale 1. */
+export interface IScaledDecimal {
+    units: bigint;
+    scale: number;
+}
+export declare const powerOfTen: (exponentArg: number) => bigint;
+export declare const parseDecimal: (textArg: unknown) => IScaledDecimal | undefined;
+/** The units of a decimal at a scale at least its own. */
+export declare const atScale: (decimalArg: IScaledDecimal, scaleArg: number) => bigint;
+/** numerator / denominator, rounded half away from zero ("kaufmännisch"); the denominator is positive. */
+export declare const divideRounded: (numeratorArg: bigint, denominatorArg: bigint) => bigint;
+/** Units of 10^-scale written as a decimal with exactly `scaleArg` digits after the point: `-22` at 1 is `'-2.2'`. */
+export declare const formatUnits: (unitsArg: bigint, scaleArg: number) => string;

package/dist_ts/cpi/decimal.js

@@ -0,0 +1,33 @@
+/** A decimal written with digits and at most one point between them; no sign, no exponent, no comma, no leading zero. */
+const DECIMAL = /^(0|[1-9]\d*)(?:\.(\d+))?$/u;
+const TEN = 10n;
+export const powerOfTen = (exponentArg) => TEN ** BigInt(exponentArg);
+export const parseDecimal = (textArg) => {
+    const match = typeof textArg === 'string' ? DECIMAL.exec(textArg) : null;
+    if (!match) {
+        return undefined;
+    }
+    const fraction = match[2] ?? '';
+    return { units: BigInt(`${match[1]}${fraction}`), scale: fraction.length };
+};
+/** The units of a decimal at a scale at least its own. */
+export const atScale = (decimalArg, scaleArg) => decimalArg.units * powerOfTen(scaleArg - decimalArg.scale);
+/** numerator / denominator, rounded half away from zero ("kaufmännisch"); the denominator is positive. */
+export const divideRounded = (numeratorArg, denominatorArg) => {
+    const negative = numeratorArg < 0n;
+    const magnitude = negative ? -numeratorArg : numeratorArg;
+    let quotient = magnitude / denominatorArg;
+    if ((magnitude % denominatorArg) * 2n >= denominatorArg) {
+        quotient += 1n;
+    }
+    return negative ? -quotient : quotient;
+};
+/** Units of 10^-scale written as a decimal with exactly `scaleArg` digits after the point: `-22` at 1 is `'-2.2'`. */
+export const formatUnits = (unitsArg, scaleArg) => {
+    const negative = unitsArg < 0n;
+    const digits = (negative ? -unitsArg : unitsArg).toString().padStart(scaleArg + 1, '0');
+    const whole = digits.slice(0, digits.length - scaleArg);
+    const fraction = digits.slice(digits.length - scaleArg);
+    return `${negative ? '-' : ''}${whole}${scaleArg > 0 ? `.${fraction}` : ''}`;
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/cpi/index.d.ts

@@ -0,0 +1,5 @@
+export * from './interfaces.js';
+export { CpiError, type ICpiErrorDetails, type TCpiErrorCode } from './classes.cpierror.js';
+export { bundesbankCpiBaseUrl, bundesbankVpiAnnualKey, bundesbankVpiFirstMonth, bundesbankVpiFirstYear, bundesbankVpiMonthlyKey, defaultCpiTimeoutMs, destatisLicence, } from './constants.js';
+export { cpiChangePercent, cpiChangePoints, cpiFirstReaching, cpiScaleAmount, cpiThresholds } from './indexmath.js';
+export { BundesbankCpiClient } from './classes.bundesbankcpiclient.js';

package/dist_ts/cpi/index.js

@@ -0,0 +1,9 @@
+// This entry point stands alone: it imports nothing from the rest of the package and has no
+// dependencies. It keeps nothing: every answer goes to the caller, with the source's answer as it
+// arrived, which the caller keeps as the evidence of an index adjustment.
+export * from './interfaces.js';
+export { CpiError } from './classes.cpierror.js';
+export { bundesbankCpiBaseUrl, bundesbankVpiAnnualKey, bundesbankVpiFirstMonth, bundesbankVpiFirstYear, bundesbankVpiMonthlyKey, defaultCpiTimeoutMs, destatisLicence, } from './constants.js';
+export { cpiChangePercent, cpiChangePoints, cpiFirstReaching, cpiScaleAmount, cpiThresholds } from './indexmath.js';
+export { BundesbankCpiClient } from './classes.bundesbankcpiclient.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy9jcGkvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsNEZBQTRGO0FBQzVGLGtHQUFrRztBQUNsRywwRUFBMEU7QUFDMUUsY0FBYyxpQkFBaUIsQ0FBQztBQUNoQyxPQUFPLEVBQUUsUUFBUSxFQUE2QyxNQUFNLHVCQUF1QixDQUFDO0FBQzVGLE9BQU8sRUFDTCxvQkFBb0IsRUFDcEIsc0JBQXNCLEVBQ3RCLHVCQUF1QixFQUN2QixzQkFBc0IsRUFDdEIsdUJBQXVCLEVBQ3ZCLG1CQUFtQixFQUNuQixlQUFlLEdBQ2hCLE1BQU0sZ0JBQWdCLENBQUM7QUFDeEIsT0FBTyxFQUFFLGdCQUFnQixFQUFFLGVBQWUsRUFBRSxnQkFBZ0IsRUFBRSxjQUFjLEVBQUUsYUFBYSxFQUFFLE1BQU0sZ0JBQWdCLENBQUM7QUFDcEgsT0FBTyxFQUFFLG1CQUFtQixFQUFFLE1BQU0sa0NBQWtDLENBQUMifQ==

package/dist_ts/cpi/indexmath.d.ts

@@ -0,0 +1,35 @@
+import type { ICpiReachOptions, ICpiScaleOptions, ICpiThresholds, ICpiValue, TCpiFrequency } from './interfaces.js';
+/** The frequency a period is written in, or `undefined` for something that is no period. */
+export declare const frequencyOf: (periodArg: unknown) => TCpiFrequency | undefined;
+/**
+ * The change from one value to another in percent, as the Statistisches Bundesamt computes it:
+ * ((new / old) × 100) − 100, rounded half away from zero to one decimal (`'13.0'`, `'-2.2'`).
+ * It does not depend on the base, but both values must be read on the same one.
+ */
+export declare const cpiChangePercent: (oldArg: ICpiValue, newArg: ICpiValue) => string;
+/**
+ * The change from one value to another in index points (new − old), with the digits of the more
+ * precise value (`'12.2'`, `'-1.0'`). Points depend on the base, so they are only given within one.
+ */
+export declare const cpiChangePoints: (oldArg: ICpiValue, newArg: ICpiValue) => string;
+/**
+ * The thresholds of a percent rule: reference × (1 + percent / 100) and reference × (1 − percent / 100),
+ * rounded half away from zero to the reference value's digits (99.7 and 5 % give 104.7 and 94.7).
+ */
+export declare const cpiThresholds: (referenceArg: ICpiValue, percentArg: string) => ICpiThresholds;
+/**
+ * The first value after the reference period that reaches a threshold of a percent rule
+ * (`cpiThresholds`), or `undefined` while none does. Whether the threshold itself counts (`reached`) or
+ * only a value beyond it (`exceeded`), and which direction, is the clause's to say. All values must be
+ * published values of the reference value's series and base; their order does not matter, a period
+ * given twice is refused.
+ */
+export declare const cpiFirstReaching: (valuesArg: readonly ICpiValue[], referenceArg: ICpiValue, percentArg: string, optionsArg: ICpiReachOptions) => ICpiValue | undefined;
+/**
+ * An amount in cents scaled from one index value to another, rounded half away from zero to whole cents:
+ * by the index ratio (amount × new / old, the default, as the Statistisches Bundesamt writes it) or by
+ * the change in percent rounded to one decimal (`basis: 'rounded_percent'`). Which one applies is the
+ * contract's to say. The amount and the result are safe integers; a negative amount (a credit) scales
+ * the same way.
+ */
+export declare const cpiScaleAmount: (amountCentsArg: number, oldArg: ICpiValue, newArg: ICpiValue, optionsArg?: ICpiScaleOptions) => number;