feat!: nvton class initial implementation

Author: Novout

README.md

@@ -14,6 +14,7 @@
 - ✅ Local or File Object
 - ✅ Support JSON
 - ✅ Exclude Wrong Data
+- ✅ Supports Node v18+
 
 ## Syntax
 

package.json

@@ -38,7 +38,7 @@
     "build": "pnpm format && tsdown --minify",
     "test": "vitest run --coverage",
     "test:dev": "vitest",
-    "format": "prettier --write src/ tests/",
+    "format": "prettier --write src/ test/",
     "prepublishOnly": "pnpm build",
     "patch": "pnpm build && generi log patch",
     "minor": "pnpm build && generi log minor",

pnpm-lock.yaml

@@ -2,6 +2,8 @@ export const OPEN_BRACKET = '[';
 export const CLOSE_BRACKET = ']';
 export const OPEN_BRACE = '{';
 export const CLOSE_BRACE = '}';
+export const OPEN_CALL = '(';
+export const CLOSE_CALL = ')';
 
 export const BACKSLASH = '\\';
 export const DOUBLE_QUOTE = '"';
@@ -16,3 +18,4 @@ export const COLON = ':';
 export const SPACE = ' ';
 
 export const WRONG_KEY = '__WRONG_KEY__';
+export const NULL_KEY = '__NULL_KEY__';

src/constants.ts

@@ -1,8 +1,41 @@
+import { LexerKey, LexerResult } from './types';
+
 export class NVTON {
-	// TODO: type
-	private data: Map<any, any>;
+	// TODO: unknown deep type
+	private data: Map<LexerKey, unknown>;
 
-	constructor(_data: any[]) {
+	constructor(lexeme: LexerResult) {
 		this.data = new Map();
+
+		this.set(lexeme);
+	}
+
+	private set(lexeme: LexerResult) {
+		lexeme.forEach((item) => {
+			if (Array.isArray(item)) this.set(item);
+			else {
+				this.data.set(item.key, item.data);
+			}
+		});
+	}
+
+	public get(target: number | string) {
+		if (typeof target === 'number') {
+			return target;
+			/*
+			let index = 0;
+
+			this.data.forEach((value, key) => {
+				if (index === target) return value;
+
+				index++;
+			});
+
+			// TODO: better tracking
+			return undefined;
+      */
+		}
+
+		return this.data.get(target);
 	}
 }

src/data.ts

@@ -1,72 +1,85 @@
 import {
 	CLOSE_BRACE,
 	CLOSE_BRACKET,
+	COMMA,
 	OPEN_BRACE,
 	OPEN_BRACKET,
+	OPEN_CALL,
+	PIPE,
 	WRONG_KEY,
 } from './constants';
 import { parseKey } from './parser';
+import { v4 } from 'uuid';
+import { LexerResult, LexerType } from './types';
 
-export const getNVTONType = (str: string) => {
+export const getNVTONType = (str: string): LexerType => {
 	return str.startsWith(OPEN_BRACE) && str.endsWith(CLOSE_BRACE)
-		? 'json'
+		? 'object'
 		: str.startsWith(OPEN_BRACKET) && str.endsWith(CLOSE_BRACKET)
-			? 'object'
-			: 'default';
+			? 'tuple'
+			: str.startsWith(OPEN_CALL)
+				? 'function'
+				: 'default';
 };
 
 const getCommonTypeCase = (str: string) => {
 	const type = getNVTONType(str);
 
-	if (type === 'default') {
+	if (type === 'object' || type === 'default') {
 		return {
-			data: str,
-			type,
-		};
-	}
-
-	if (type === 'json') {
-		return {
-			data: parseKey(str),
+			key: type === 'default' ? str : v4(),
+			data: parseKey(str, type),
 			type,
 		};
 	}
 
 	return true;
 };
 
-const normalizeStr = (str: string) => str.substring(1, str.length - 1);
+const normalize = (str: string) => str.substring(1, str.length - 1).trim();
 
-// TODO: type
-export const lex = (raw: string): any[] => {
-	return normalizeStr(raw)
-		.split(/,/g)
+const isTuple = (tuple: string) =>
+	tuple.startsWith(OPEN_BRACKET) && tuple.endsWith(CLOSE_BRACKET);
+
+export const lex = (raw: string): LexerResult => {
+	if (!isTuple(raw)) return [];
+
+	return normalize(raw)
+		.split(`${COMMA} `)
 		.map((str) => {
 			const def = getCommonTypeCase(str);
 
 			if (def !== true) return def;
 
-			const tuples = normalizeStr(str)
-				.split(/,/g)
+			if (!isTuple(str)) return [];
+
+			const tuples = normalize(str)
+				.split(`${COMMA} `)
 				.map((tuple) => {
-					const data = normalizeStr(tuple).split('|');
+					const data = normalize(tuple)
+						.split(PIPE)
+						.map((tg) => tg.trim())
+						.filter(Boolean);
 
-					if (data.length !== 2) return WRONG_KEY;
+					if (data.length < 1 || data.length > 2) return WRONG_KEY;
 
-					const [key, value] = data;
+					const structure =
+						data.length === 1
+							? { key: data[0], value: data[0] }
+							: { key: data[0], value: data[1] };
 
-					const _def = getCommonTypeCase(value);
+					const _def = getCommonTypeCase(structure.value);
 
-					if (_def !== true)
+					if (_def !== true) {
 						return {
-							data: {
-								key,
-								value: _def.data,
-							},
+							key: structure.key,
+							data: _def.data,
 							type: _def.type,
 						};
+					}
+
 					// TODO: support recursive tuple format
-					else return WRONG_KEY;
+					return WRONG_KEY;
 				})
 				.filter((tuple) => tuple !== WRONG_KEY);
 

src/lexer.ts

@@ -1,6 +1,12 @@
-import destr from 'destr';
+import { destr } from 'destr';
+import { LexerType } from './types';
 
-export function parseKey<T = unknown>(raw: string) {
-	// TODO: strict: true with error support
-	return destr<T>(raw, { strict: false });
+const stringObjectToObject = (raw: string) => {
+	return raw.replace(/(\w+:)|(\w+ :)/g, (str) => {
+		return '"' + str.substring(0, str.length - 1) + '":';
+	});
+};
+
+export function parseKey<T = unknown>(raw: string, type: LexerType = 'default') {
+	return destr<T>(type === 'object' ? stringObjectToObject(raw) : raw, { strict: false });
 }

src/parser.ts

@@ -1,37 +1,18 @@
-import { existsSync, readFileSync } from 'fs-extra';
-import { getPath } from './utils';
-import { Maybe } from './types';
+import { getFile } from './utils';
 import { lex } from './lexer';
 import { NVTON } from './data';
 
-const getFile = (target: string): Maybe<string> => {
-	const path = getPath(target);
+const get = (raw: string): NVTON => {
+	const resolved = (raw.endsWith('.nvton') ? getFile(raw) : raw)?.trim();
 
-	const existsPath = existsSync(path);
+	if (!resolved && resolved !== '') {
+		throw new Error(`${raw} file not found!`);
+	}
 
-	if (!existsPath) return undefined;
+	const data = lex(resolved);
 
-	return readFileSync(path).toString() || undefined;
+	return new NVTON(data);
 };
 
-const get = (raw: Maybe<string>) => {
-	if (!raw) return undefined;
-
-	const data = lex(raw);
-
-	const nvton = new NVTON(data);
-};
-
-export const nvton = (raw: string) => {
-	get(raw);
-};
-
-export const getNvton = (target: string) => {
-	const raw = getFile(target);
-
-	if (!raw) return false;
-
-	get(raw);
-};
-
-export const readNvton = () => {};
+export const nvton = (raw: string) => get(raw);
+export const write = () => {};

src/pipeline.ts

@@ -1 +1,10 @@
+import { NVTON } from './data';
+
 export type Maybe<T = void> = T | undefined | null;
+
+export type Nvton = typeof NVTON;
+
+export type LexerType = 'object' | 'tuple' | 'function' | 'default';
+export type LexerKey = string | number;
+export type LexerCommon = { key: string; data: unknown; type: LexerType };
+export type LexerResult = (LexerCommon | LexerCommon[])[];