Data

Filter les clés par inclusion

filterByKeyInclusion est une fonction permettant de filtrer un objet en incluant uniquement les clés spécifiées.

Inclure uniquement certaines clés

import { filterByKeyInclusion } from '@basalt-lab/basalt-helper/data';

const data = {
    a: 'a',
    b: 'b',
    c: 'c',
    d: 'd',
} as const;

const filteredData = filterByKeyInclusion(data, ['a', 'b', 'c']);
console.log(filteredData);

bun example.ts{ a: 'a', b: 'b', c: 'c' }

Inclure uniquement certaines clés et seulement si elles ont une valeur

import { filterByKeyInclusion } from '@basalt-lab/basalt-helper/data';

const data = {
    a: 'a',
    b: undefined,
    c: null,
    d: 'd',
} as const;

const filteredData = filterByKeyInclusion(data, ['a', 'b', 'c'], true);
console.log(filteredData);

bun example.ts{ a: 'a' }

Filter les clés par exclusion

filterByKeyExclusion est une fonction permettant de filtrer un objet en excluant les clés spécifiées.

Exclure certaines clés

import { filterByKeyExclusion } from '@basalt-lab/basalt-helper/data';

const data = {
    a: 'a',
    b: 'b',
    c: 'c',
    d: 'd',
} as const;

const filteredData = filterByKeyExclusion(data, ['a', 'b']);
console.log(filteredData);

bun example.ts{ c: 'c', d: 'd' }

Exclure certaines clés et exclure ceux qui n'ont pas de valeur

import { filterByKeyExclusion } from '@basalt-lab/basalt-helper/data';

const data = {
    a: 'a',
    b: null,
    c: undefined,
    d: 'd',
} as const;

const filteredData = filterByKeyExclusion(data, ['a'], true);
console.log(filteredData);

bun example.ts{ d: 'd' }

Inclure les clefs selon un pattern

filterByKey est une fonction permettant de filtrer un objet en incluant les clefs selon un pattern.

Inclure les clefs selon un pattern

import { filterByValue } from '@basalt-lab/basalt-helper/data';

const data = {
    a: 'a',
    b: 'b',
    c: 'c',
    d: 'd',
} as const;

const filteredData = filterByValue(data, (value: string): boolean => value === 'a' || value === 'b');
console.log(filteredData);

bun example.ts{ a: 'a', b: 'b' }

Inclure les clefs selon un pattern et seulement si elles ont une valeur

import { filterByValue } from '@basalt-lab/basalt-helper/data';

const data = {
    a: 'a',
    b: undefined,
    c: null,
    d: 'd',
} as const;

const filteredData = filterByValue(data, (value: unknown): boolean => value === 'a', true);
console.log(filteredData);

bun example.ts{ a: 'a' }

Exclure les clefs selon un pattern

filterByValue est une fonction permettant de filtrer un objet en excluant les clefs selon un pattern.

Exclure les clefs selon un pattern

import { filterByValue } from '@basalt-lab/basalt-helper/data';

const data = {
    a: 'a',
    b: 'b',
    c: 'c',
    d: 'd',
} as const;

const filteredData = filterByValue(data, (value: string): boolean => value !== 'a' && value !== 'b');
console.log(filteredData);

bun example.ts{ c: 'c', d: 'd' }

Exclure les clefs selon un pattern et exclure ceux qui n'ont pas de valeur

import { filterByValue } from '@basalt-lab/basalt-helper/data';

const data = {
    a: 'a',
    b: null,
    c: undefined,
    d: 'd',
} as const;

const filteredData = filterByValue(data, (value: unknown): boolean => value !== 'a', true);
console.log(filteredData);

bun example.ts{ d: 'd' }

Transformer les clés d'un objet

transformKeys est une fonction permettant de transformer les clés d'un objet selon un transformateur spécifié.

Transformation des clés d'un objet en camelCase

import { transformKeys } from '@basalt-lab/basalt-helper/data';
import { BasaltCamelCaseTransformer } from '@basalt-lab/basalt-helper/data/transformer';

const data = {
    'camelCase': undefined,
    'PascalCase': undefined,
    'kebab-case': undefined,
    'snake_case': undefined
};

console.log(transformKeys(data, new BasaltCamelCaseTransformer()));

bun example.ts{
camelCase: undefined,
pascalCase: undefined,
kebabCase: undefined,
snakeCase: undefined
}

Transformation des clés d'un objet en PascalCase

import { transformKeys } from '@basalt-lab/basalt-helper/data';
import { BasaltPascalCaseTransformer } from '@basalt-lab/basalt-helper/data/transformer';

const data = {
    'camelCase': undefined,
    'PascalCase': undefined,
    'kebab-case': undefined,
    'snake_case': undefined
};

console.log(transformKeys(data, new BasaltPascalCaseTransformer()));

bun example.ts{
CamelCase: undefined,
PascalCase: undefined,
KebabCase: undefined,
SnakeCase: undefined
}

Transformation des clés d'un objet en kebab-case

import { transformKeys } from '@basalt-lab/basalt-helper/data';
import { BasaltKebabCaseTransformer } from '@basalt-lab/basalt-helper/data/transformer';

const data = {
    'camelCase': undefined,
    'PascalCase': undefined,
    'kebab-case': undefined,
    'snake_case': undefined
};

console.log(transformKeys(data, new BasaltKebabCaseTransformer()));

bun example.ts{
'camel-case': undefined,
'pascal-case': undefined,
'kebab-case': undefined,
'snake-case': undefined
}

Transformation des clés d'un objet en snake_case

import { transformKeys } from '@basalt-lab/basalt-helper/data';
import { BasaltSnakeCaseTransformer } from '@basalt-lab/basalt-helper/data/transformer';

const data = {
    'camelCase': undefined,
    'PascalCase': undefined,
    'kebab-case': undefined,
    'snake_case': undefined
};

console.log(transformKeys(data, new BasaltSnakeCaseTransformer()));

bun example.ts{
camel_case: undefined,
pascal_case: undefined,
kebab_case: undefined,
snake_case: undefined
}