ohadakit 1.0.0

package/dist/types/data/ohada/types.d.ts

@@ -0,0 +1,39 @@
+export interface OhadaAccount {
+    code: string;
+    name: string;
+    level: number;
+    parentCode?: string;
+    subAccounts?: OhadaAccount[];
+}
+export interface OhadaFlatAccount {
+    code: string;
+    name: string;
+    level: number;
+    classCode: string;
+    parentCode?: string;
+    path: string;
+}
+export interface OhadaClass {
+    code: string;
+    name: string;
+    nameEn?: string;
+    namePt?: string;
+    nameEs?: string;
+    accounts: OhadaAccount[];
+}
+export interface OhadaClassReference {
+    code: string;
+    name: string;
+    nameEn?: string;
+    namePt?: string;
+    nameEs?: string;
+    file: string;
+}
+export interface OhadaChartIndex {
+    version: string;
+    name: string;
+    source: string;
+    date: string;
+    classes: OhadaClassReference[];
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types/data/ohada-accounts.d.ts

@@ -0,0 +1,6 @@
+import type { RawAccountData, OhadaClass } from '../core/types';
+export declare const OHADA_CLASSES: Record<string, OhadaClass>;
+export declare function loadOhadaAccounts(): RawAccountData[];
+export declare function getClassMetadata(classCode: string): OhadaClass | null;
+export declare function getAllClassCodes(): string[];
+//# sourceMappingURL=ohada-accounts.d.ts.map

package/dist/types/export/Exporter.d.ts

@@ -0,0 +1,11 @@
+import type { Account } from '../core/Account';
+import type { JsonExportOptions, CsvExportOptions } from '../core/types';
+export declare class JsonExporter {
+    static export(accounts: Account[], options?: JsonExportOptions): string;
+    private static buildHierarchical;
+}
+export declare class CsvExporter {
+    static export(accounts: Account[], options?: CsvExportOptions): string;
+    private static escapeCSV;
+}
+//# sourceMappingURL=Exporter.d.ts.map

package/dist/types/i18n/TranslationService.d.ts

@@ -0,0 +1,15 @@
+import type { OhadaLocale, LocalizedString } from './types';
+export declare class TranslationService {
+    private static readonly VALID_LOCALES;
+    private locale;
+    constructor(locale?: OhadaLocale);
+    static isValidLocale(locale: string): locale is OhadaLocale;
+    getAccountName(code: string, fallbackName: string): string;
+    getAccountTranslations(code: string): LocalizedString | null;
+    hasTranslation(code: string): boolean;
+    hasLocaleTranslation(code: string, locale: OhadaLocale): boolean;
+    getLocale(): OhadaLocale;
+    setLocale(locale: OhadaLocale): void;
+    static getAvailableLocales(): OhadaLocale[];
+}
+//# sourceMappingURL=TranslationService.d.ts.map

package/dist/types/i18n/account-names.d.ts

@@ -0,0 +1,3 @@
+import type { AccountTranslations } from './types';
+export declare const accountTranslations: AccountTranslations;
+//# sourceMappingURL=account-names.d.ts.map

package/dist/types/i18n/index.d.ts

@@ -0,0 +1,4 @@
+export type { OhadaLocale, LocalizedString, AccountTranslations, ClassTranslations } from './types';
+export { TranslationService } from './TranslationService';
+export { accountTranslations } from './account-names';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/i18n/types.d.ts

@@ -0,0 +1,13 @@
+export type { OhadaLocale } from '../core/types';
+export interface LocalizedString {
+    fr: string;
+    en?: string;
+    pt?: string;
+    es?: string;
+}
+export type AccountTranslations = Record<string, LocalizedString>;
+export interface ClassTranslations {
+    name: LocalizedString;
+    description?: LocalizedString;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types/index.d.ts

@@ -0,0 +1,25 @@
+export { LedgerEngine, createLedgerEngine, getDefaultLedgerEngine } from './LedgerEngine';
+export { AccountBook, createAccountBook } from './AccountBook';
+export type { CreateAccountBookOptions } from './AccountBook';
+export { Account, isAccount } from './core/Account';
+export { AccountRegistry, getDefaultRegistry, resetDefaultRegistry } from './core/AccountRegistry';
+export { AccountIndex } from './core/AccountIndex';
+export { QueryBuilder } from './query/QueryEngine';
+export { MemoryStorage } from './storage/MemoryStorage';
+export { LocalStorageAdapter } from './storage/LocalStorage';
+export { JsonExporter, CsvExporter } from './export/Exporter';
+export { validateAccountCode, validateAccountCodeFormat, validateClassCode, validateAccountLevel, isValidAccountCodeFormat, isValidClassCode, sanitizeAccountCode, getAccountLevelFromCode, extractClassCode, extractParentCode, } from './validation/validators';
+export { OhadaKitError, AccountNotFoundError, InvalidAccountCodeFormatError, InvalidAccountLevelError, InvalidClassCodeError, StorageError, ExportError, } from './validation/errors';
+export type { AccountCode, ClassCode, Result, RawAccountData, AccountMetadata, AccountJSON, OhadaClass, OhadaLocale, QueryFilter, SearchOptions, SortOptions, RegistryStats, ExportFormat, JsonStructure, JsonExportOptions, CsvExportOptions, ExportOptions, StorageAdapter, LedgerEngineOptions, AccountBookOptions, AccountBookSnapshot, AccountBookStats, } from './core/types';
+export { TranslationService } from './i18n/TranslationService';
+export { accountTranslations } from './i18n/account-names';
+export type { LocalizedString, AccountTranslations, ClassTranslations } from './i18n/types';
+export { Ok, Err, isOk, isErr, isClassCode } from './core/types';
+export { loadOhadaAccounts, getClassMetadata, getAllClassCodes, OHADA_CLASSES } from './data/ohada-accounts';
+export { CustomAccountManager } from './custom/CustomAccountManager';
+export { CustomAccountValidator } from './custom/CustomAccountValidator';
+export { CustomAccountIndex } from './custom/CustomAccountIndex';
+export type { CustomAccountInput, CustomAccountData, LabelOverride, CustomAccountStorage, CustomAccountManagerOptions, CreateAccountResult, UpdateLabelResult, DeleteAccountResult, CustomAccountStats, } from './custom/types';
+export { STORAGE_KEYS as CUSTOM_STORAGE_KEYS, DEFAULT_STORAGE_PREFIX, STORAGE_VERSION, } from './custom/types';
+export { CustomAccountError, CannotModifyMainAccountError, CannotCreateMainAccountError, ParentAccountNotFoundError, AccountCodeConflictError, InvalidCustomCodeError, CustomStorageError, } from './custom/errors';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/query/QueryEngine.d.ts

@@ -0,0 +1,30 @@
+import type { Account } from '../core/Account';
+import type { AccountRegistry } from '../core/AccountRegistry';
+import type { SearchOptions } from '../core/types';
+export declare class QueryBuilder {
+    private registry;
+    private filters;
+    private searchText?;
+    private searchOpts?;
+    private sortOpts?;
+    private limitValue?;
+    private offsetValue?;
+    constructor(registry: AccountRegistry);
+    inClass(classCode: string | string[]): this;
+    atLevel(level: number | number[]): this;
+    withParent(parentCode: string): this;
+    nameContains(text: string): this;
+    codeMatches(pattern: RegExp): this;
+    where(predicate: (account: Account) => boolean): this;
+    search(text: string, options?: SearchOptions): this;
+    sortBy(by: 'code' | 'name' | 'level', direction?: 'asc' | 'desc'): this;
+    limit(count: number): this;
+    offset(count: number): this;
+    execute(): Account[];
+    count(): number;
+    first(): Account | null;
+    exists(): boolean;
+    private applyFilters;
+    private applySorting;
+}
+//# sourceMappingURL=QueryEngine.d.ts.map

package/dist/types/storage/LocalStorage.d.ts

@@ -0,0 +1,14 @@
+import type { StorageAdapter } from '../core/types';
+export declare class LocalStorageAdapter implements StorageAdapter {
+    private prefix;
+    private storage;
+    constructor(prefix?: string);
+    private getPrefixedKey;
+    private removePrefixFromKey;
+    get(key: string): Promise<string | null>;
+    set(key: string, value: string): Promise<void>;
+    delete(key: string): Promise<void>;
+    getAll(): Promise<Map<string, string>>;
+    clear(): Promise<void>;
+}
+//# sourceMappingURL=LocalStorage.d.ts.map

package/dist/types/storage/MemoryStorage.d.ts

@@ -0,0 +1,11 @@
+import type { StorageAdapter } from '../core/types';
+export declare class MemoryStorage implements StorageAdapter {
+    private storage;
+    constructor();
+    get(key: string): Promise<string | null>;
+    set(key: string, value: string): Promise<void>;
+    delete(key: string): Promise<void>;
+    getAll(): Promise<Map<string, string>>;
+    clear(): Promise<void>;
+}
+//# sourceMappingURL=MemoryStorage.d.ts.map

package/dist/types/validation/errors.d.ts

@@ -0,0 +1,43 @@
+export declare abstract class OhadaKitError extends Error {
+    abstract readonly code: string;
+    constructor(message: string);
+    toJSON(): {
+        name: string;
+        code: string;
+        message: string;
+    };
+}
+export declare class AccountNotFoundError extends OhadaKitError {
+    readonly code = "ACCOUNT_NOT_FOUND";
+    readonly accountCode: string;
+    constructor(accountCode: string);
+}
+export declare class InvalidAccountCodeFormatError extends OhadaKitError {
+    readonly code = "INVALID_ACCOUNT_CODE_FORMAT";
+    readonly accountCode: string;
+    readonly reason: string;
+    constructor(accountCode: string, reason: string);
+}
+export declare class InvalidAccountLevelError extends OhadaKitError {
+    readonly code = "INVALID_ACCOUNT_LEVEL";
+    readonly level: number;
+    constructor(level: number);
+}
+export declare class InvalidClassCodeError extends OhadaKitError {
+    readonly code = "INVALID_CLASS_CODE";
+    readonly classCode: string;
+    constructor(classCode: string);
+}
+export declare class StorageError extends OhadaKitError {
+    readonly code = "STORAGE_ERROR";
+    readonly operation: string;
+    readonly originalError?: Error;
+    constructor(operation: string, message: string, originalError?: Error);
+}
+export declare class ExportError extends OhadaKitError {
+    readonly code = "EXPORT_ERROR";
+    readonly format: string;
+    readonly originalError?: Error;
+    constructor(format: string, message: string, originalError?: Error);
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/types/validation/validators.d.ts

@@ -0,0 +1,14 @@
+import type { Result } from '../core/types';
+import type { Account } from '../core/Account';
+import type { AccountRegistry } from '../core/AccountRegistry';
+export declare function validateAccountCodeFormat(code: string): Result<string>;
+export declare function validateClassCode(code: string): Result<string>;
+export declare function validateAccountLevel(level: number): Result<number>;
+export declare function validateAccountCode(code: string, registry: AccountRegistry): Result<Account>;
+export declare function isValidAccountCodeFormat(code: string): boolean;
+export declare function isValidClassCode(code: string): boolean;
+export declare function sanitizeAccountCode(code: string): string;
+export declare function getAccountLevelFromCode(code: string): number;
+export declare function extractClassCode(code: string): string;
+export declare function extractParentCode(code: string): string | null;
+//# sourceMappingURL=validators.d.ts.map

package/package.json

@@ -0,0 +1,75 @@
+{
+  "name": "ohadakit",
+  "version": "1.0.0",
+  "description": "TypeScript SDK for the OHADA/SYSCOHADA chart of accounts — O(1) lookups, querying, custom accounts, i18n, and export",
+  "type": "module",
+  "main": "./dist/cjs/index.js",
+  "module": "./dist/esm/index.js",
+  "types": "./dist/types/index.d.ts",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/types/index.d.ts",
+      "browser": "./dist/browser/ohadakit.umd.js",
+      "import": "./dist/esm/index.js",
+      "require": "./dist/cjs/index.js"
+    },
+    "./browser": {
+      "types": "./dist/types/index.d.ts",
+      "import": "./dist/browser/ohadakit.iife.js",
+      "default": "./dist/browser/ohadakit.umd.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist/esm/**/*.js",
+    "dist/cjs/**/*.js",
+    "dist/types/**/*.d.ts",
+    "dist/browser/**/*.js",
+    "!dist/**/*.map",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "npm run clean && npm run build:types && npm run build:lib && npm run build:browser && npm run build:report",
+    "build:types": "tsc --project tsconfig.build.json",
+    "build:lib": "vite build --mode production",
+    "build:browser": "vite build --config vite.config.browser.ts --mode production",
+    "build:report": "node scripts/build-report.js",
+    "clean": "rm -rf dist",
+    "test": "vitest run",
+    "test:watch": "vitest --watch",
+    "test:coverage": "vitest run --coverage",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "npm run typecheck && npm run test && npm run build"
+  },
+  "keywords": [
+    "ohada",
+    "syscohada",
+    "accounting",
+    "chart-of-accounts",
+    "ledger",
+    "typescript",
+    "sdk"
+  ],
+  "author": "Justin Dah-kenangnon <dah.kenangnon@gmail.com>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Dahkenangnon/OhadaKit.git"
+  },
+  "bugs": {
+    "url": "https://github.com/Dahkenangnon/OhadaKit/issues"
+  },
+  "homepage": "https://github.com/Dahkenangnon/OhadaKit#readme",
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "@vitest/coverage-v8": "^1.0.0",
+    "typescript": "^5.3.0",
+    "vite": "^7.2.6",
+    "vitest": "^1.0.0"
+  },
+  "engines": {
+    "node": ">=16.0.0"
+  }
+}