@kurone-kito/dantalion-i18n v0.19.2

🦁 Dantalion: i18n resources library

This package provides a function that infers the personality details from the specified birthday. By using this package, you can quickly implement birthday divination in your Node.js apps. Its calculation is using the method of Four Pillars of Destiny (Ba-Zi).

This package is a library that obtains human-readable (Markdown format) details for the output of the @kurone-kito/dantalion-core package.

This library uses the Intl API to determine the language and outputs it in the appropriate language. It's only in Japanese and partly English yet, but we'll gradually support multiple languages.

Usage

Require: Node.js >= v12.1

Add to dependency

npm install -S @kurone-kito/dantalion-core @kurone-kito/dantalion-i18n

Get the details of the personality

const { getPersonality } = require('@kurone-kito/dantalion-core');
const { genius } = require('@kurone-kito/dantalion-i18n');

const personality = getPersonality('1993-10-09');
console.log(personality.inner); // === '555'

const result = genius.getValue(personality.inner);

console.log(JSON.stringify(result));

Result

In strictly, The function gets the raw object, not the JSON. Since it's a long sentence, it omitted some parts.

{
  "name": "Easygoing type",
  "summary": "Balanced, capable and caring, a heroic position.",
  "detail": [
    "Many people have an air of all-around competence and boss authority, like an executive employee.",
    :
    :
  ],
  "weak": [
    "They don't like to apologize even when it is their fault. Even if they have apologetic, they are not very good at expressing it."
    :
    :
  ],
  "strategy": [
    "They can do everything on their own, so they tend to take care of everything on their own. When you entrust them with something, be careful not to let them do too much."
  ]
}

API

createAccessors(t: i18next.TFunction): Accessors

Create the concreted accessors collection from the i18next instance

Arguments

Returns

Accessors: The instance of the concreted accessors collection

createAccessorsAsync(lng?: string, additions?: i18next.ResourceLanguage): Promise<Accessors & i18next.WithT>

Create the concreted accessors collection asynchronously

It is a synonym function that combines createAccessors() and createTAsync().

Arguments

(*: If omitted, the language used is detected from the current environment. See: useLocale())

Returns

Promise<Accessors & i18next.WithT>: The instance of the concreted accessors collection

createTAsync(options?: CreateTAsyncOptions): Promise<i18next.TFunction>

Create and initialize the i18next instance asynchronously

Arguments

Returns

Promise<i18next.TFunction>: The i18next instance which already initialized the resources.

fallbackLanguage: 'en'

The language that uses as a fallback.

getDetailMarkdown(accessors: Accessors, genius?: Genius): string

Get the personality information.

Arguments

Returns

string: The string that the personality information as the Markdown format.

If you specified the undefined value as an argument or omitted it, it would be a list of the available types.

getLocale(): string | undefined

Get the locale information from the Intl API.

Arguments

(None)

Returns

string: The locale string e.g. en-US.

getPersonalityMarkdown(accessors: Accessors, birth: string | number | Date): string

Get the personality information corresponding to the specified birthday.

Arguments

Returns

string: The string that the personality information as the Markdown format. If the date is over the range, it will be error message.

locales: Record<string, string>

The locales table.

The property keys have ISO 639-1 string and values exact name.

Type definitions (for TypeScript)

The strings contained in the object are in Markdown format. In the case of an array of strings, the elements separate for each paragraph.

Accessors

The type definition of the concreted accessors collection

interface Accessors {
  readonly brain: DetailAccessor<DetailsType, Brain>;
  readonly communication: DetailAccessor<DetailsType, Communication>;
  readonly genius: DetailAccessor<
    PersonalityType,
    Genius,
    PersonalityDetailType
  >;
  readonly lifeBase: DetailAccessor<
    DetailsBaseType<string[]>,
    LifeBase,
    string
  >;
  readonly management: DetailAccessor<DetailsType, Management>;
  readonly motivation: DetailAccessor<string, Motivation, string>;
  readonly position: DetailAccessor<DetailsType, Position>;
  readonly potential?: DetailAccessor<
    readonly string[],
    readonly [Potential, Potential]
  >;
  readonly response: DetailAccessor<DetailsType, Response>;
  readonly vector: DetailAccessor<VectorType, Vector>;
  getDescription(type?: string): DesctiptionsType;
}

CreateTAsyncOptions

The type definition that the options of the createTAsync function.

interface CreateTAsyncOptions {
  readonly additions?: i18next.ResourceLanguage;
  readonly lng?: string;
  readonly use?:
    | i18next.Module
    | i18next.Newable<i18next.Module>
    | i18next.ThirdPartyModule[]
    | i18next.Newable<i18next.ThirdPartyModule>[];
}

(*: See the type definition as it is long :/)

DesctiptionsType

The type definition that the resources of description.

interface DesctiptionsType {
  readonly cc: string;
  readonly detail: string;
  readonly details: string;
  readonly genius1: string;
  readonly genius2: string;
  readonly invalid: string;
  readonly personality: string;
  readonly strategy: string;
  readonly weak: string;
}

DetailAccessor<T, K, D>

The type definition with a function to access a resource of the specific category.

interface DetailAccessor<
  T extends i18next.TFunctionResult,
  K,
  D extends DetailsBaseType | string = DetailsBaseType
> {
  getByKey(key: K): T;
  getCategoryDetail(): D;
}

DetailsBaseType<T>

The type definition that the pair of name and detail.

interface DetailsBaseType<T = string> {
  readonly detail: T;
  readonly name: string;
}

DetailsType

The type definition that the name, detail and more descriptions.

interface DetailsType {
  readonly detail: string;
  readonly name: string;
  readonly more: readonly string[];
}

PersonalityDetailBaseType

The type definition that the details of personality.

export interface PersonalityDetailBaseType {
  readonly inner: string;
  readonly outer: string;
  readonly workStyle: string;
}

PersonalityDetailType

The type definition that the details of personality.

export interface PersonalityDetailType {
  readonly descriptions: PersonalityDetailBaseType;
  readonly detail: string;
  readonly inner: string;
  readonly name: string;
  readonly outer: string;
  readonly workStyle: string;
}

PersonalityType

A type definition of a structure that stores a description of a particular person's personality.

interface PersonalityType {
  readonly detail: readonly string[];
  readonly name: string;
  readonly strategy: readonly string[];
  readonly summary: string;
  readonly weak: readonly string[];
}

VectorType

A type definition of a structure that stores a description of a personality type.

interface VectorType {
  readonly detail: string;
  readonly name: string;
  readonly strategy: readonly string[];
}

See also

• i18next: internationalization-framework

License

MIT