chore: save state

core.wasi-browser.js

@@ -58,4 +58,5 @@ const {
 export default __napiModule.exports
 export const TransformKind = __napiModule.exports.TransformKind
 export const Nephrit = __napiModule.exports.Nephrit
+export const JsNephrit = __napiModule.exports.JsNephrit
 export const NephritLogLevel = __napiModule.exports.NephritLogLevel

core.wasi.cjs

@@ -110,4 +110,5 @@ const { instance: __napiInstance, module: __wasiModule, napiModule: __napiModule
 module.exports = __napiModule.exports
 module.exports.TransformKind = __napiModule.exports.TransformKind
 module.exports.Nephrit = __napiModule.exports.Nephrit
+module.exports.JsNephrit = __napiModule.exports.JsNephrit
 module.exports.NephritLogLevel = __napiModule.exports.NephritLogLevel

crates/bindings/src/parser.rs

@@ -8,12 +8,6 @@ pub struct TokenFile {
   pub content: String,
 }
 
-#[derive(Clone, Debug)]
-pub struct ParsedFile {
-  pub path: String,
-  pub content: serde_json::Value,
-}
-
 #[napi(object)]
 #[derive(Clone)]
 pub struct Parser<'parser> {

crates/bindings/src/token.rs

@@ -18,6 +18,38 @@ pub struct ResolvedToken {
   pub file_path: String,
 }
 
+impl ResolvedToken {
+  fn to_transformed_token(&self) -> TransformedToken {
+    let formatted_value = match &self.value {
+      serde_json::Value::String(s) => s.clone(),
+      _ => self.value.to_string(),
+    };
+
+    TransformedToken {
+      key: self.key.clone(),
+      value: formatted_value,
+      file_path: self.file_path.clone(),
+      is_source: true,
+      original: self.original_value.clone(),
+      name: self.name.clone(),
+      attributes: TokenAttrs::from_path(&self.path),
+      path: self.path.clone(),
+    }
+  }
+}
+
+impl Into<TransformedToken> for ResolvedToken {
+  fn into(self) -> TransformedToken {
+    self.to_transformed_token()
+  }
+}
+
+impl From<&ResolvedToken> for TransformedToken {
+  fn from(resolved_token: &ResolvedToken) -> Self {
+    resolved_token.to_transformed_token()
+  }
+}
+
 #[napi(object)]
 #[derive(Debug, Clone, serde::Serialize)]
 pub struct TokenAttrs {
@@ -54,23 +86,3 @@ pub struct TransformedToken {
   pub attributes: TokenAttrs,
   pub path: Vec<String>,
 }
-
-impl TransformedToken {
-  pub fn from_resolved_token(resolved_token: &ResolvedToken) -> Self {
-    let formatted_value = match &resolved_token.value {
-      serde_json::Value::String(s) => s.clone(),
-      _ => resolved_token.value.to_string(),
-    };
-
-    Self {
-      key: resolved_token.key.clone(),
-      value: formatted_value,
-      file_path: resolved_token.file_path.clone(),
-      is_source: true,
-      original: resolved_token.original_value.clone(),
-      name: resolved_token.name.clone(),
-      attributes: TokenAttrs::from_path(&resolved_token.path),
-      path: resolved_token.path.clone(),
-    }
-  }
-}

crates/builtin/Cargo.toml

@@ -0,0 +1,10 @@
+[package]
+edition    = "2021"
+license    = "MIT"
+name       = "builtin"
+repository = "https://github.com/pmqueiroz/nephrit.git"
+version    = "0.1.0"
+
+[dependencies]
+bindings = { path = "../bindings" }
+log      = { path = "../log" }

crates/builtin/src/lib.rs

@@ -0,0 +1,3 @@
+mod transformers;
+
+pub use transformers::*;

crates/builtin/src/transformers/interfaces/mod.rs

@@ -0,0 +1,7 @@
+use bindings::token::TransformedToken;
+
+pub trait BuiltinTransformer {
+  fn transform(&self, token: &TransformedToken) -> TransformedToken;
+
+  fn name(&self) -> String;
+}

crates/builtin/src/transformers/mod.rs

@@ -0,0 +1,11 @@
+mod interfaces;
+mod name_kebab;
+
+pub use interfaces::BuiltinTransformer;
+pub use name_kebab::NAME_KEBAB_TRANSFORMER;
+
+const TRANSFORMERS: &[&dyn BuiltinTransformer] = &[&NAME_KEBAB_TRANSFORMER];
+
+pub fn get_transformers() -> &'static [&'static dyn BuiltinTransformer] {
+  TRANSFORMERS
+}

crates/builtin/src/transformers/name_kebab.rs

@@ -0,0 +1,35 @@
+use bindings::token::TransformedToken;
+
+pub struct NameKebab;
+
+impl super::interfaces::BuiltinTransformer for NameKebab {
+  fn transform(&self, token: &TransformedToken) -> TransformedToken {
+    let mut transformed = token.value.clone();
+    transformed = transformed
+      .chars()
+      .map(|c| {
+        if c.is_uppercase() {
+          format!("-{}", c.to_lowercase())
+        } else {
+          c.to_string()
+        }
+      })
+      .collect::<String>();
+    let transformed = if transformed.starts_with('-') {
+      transformed.trim_start_matches('-').to_string()
+    } else {
+      transformed
+    };
+
+    TransformedToken {
+      value: transformed,
+      ..token.clone()
+    }
+  }
+
+  fn name(&self) -> String {
+    "name/kebab".to_string()
+  }
+}
+
+pub const NAME_KEBAB_TRANSFORMER: NameKebab = NameKebab {};

crates/kernel/Cargo.toml

@@ -6,7 +6,7 @@ repository = "https://github.com/pmqueiroz/nephrit.git"
 version    = "0.1.0"
 
 [dependencies]
-bindings    = { path = "../bindings" }
+builtin     = { path = "../builtin" }
 glob        = "0.3.3"
 log         = { path = "../log" }
 napi        = "3.0.0"

crates/kernel/src/build/transform_tokens.rs

@@ -19,7 +19,7 @@ pub fn transform_tokens<'transforms>(
       if let Ok(filter_func) = transformer.filter.borrow_back(env) {
         let token_ref = match transformed_tokens.get(&token.key) {
           Some(t) => t.clone(),
-          None => TransformedToken::from_resolved_token(token),
+          None => token.into(),
         };
 
         let bool_result = filter_func.call(token_ref.clone());

crates/kernel/src/interfaces/mod.rs

@@ -0,0 +1 @@
+pub mod parser;

crates/kernel/src/interfaces/parser.rs

@@ -0,0 +1,5 @@
+#[derive(Clone, Debug)]
+pub struct ParsedFile {
+  pub path: String,
+  pub content: serde_json::Value,
+}

crates/kernel/src/lib.rs

@@ -1,9 +1,9 @@
-extern crate bindings;
+extern crate builtin;
 extern crate log;
 extern crate napi;
 extern crate rayon;
 extern crate utils;
-use bindings::parser::ParsedFile;
+use interfaces::parser::ParsedFile;
 use napi::bindgen_prelude::Env;
 
 use rayon::prelude::{IntoParallelRefIterator, ParallelIterator};
@@ -79,6 +79,8 @@ mod bucket;
 mod build;
 mod config;
 mod helpers;
+mod interfaces;
+pub mod nephrit;
 
 pub use bucket::TokensBucket;
 pub use build::{build, resolve_transformers};

crates/kernel/src/nephrit/mod.rs

@@ -0,0 +1,68 @@
+mod transformers;
+
+use bindings::token::{TokenAttrs, TransformedToken};
+pub use transformers::*;
+
+use crate::Config;
+use std::collections::HashMap;
+
+pub struct Nephrit<'env> {
+  config: Config<'env>,
+  transforms: HashMap<String, transformers::InternalTransformer>,
+}
+
+impl<'env> Nephrit<'env> {
+  pub fn new(config: Config<'env>) -> Self {
+    Self {
+      config,
+      transforms: HashMap::new(),
+    }
+  }
+
+  pub fn get_config(&self) -> &Config<'env> {
+    &self.config
+  }
+
+  pub fn register_transform(&mut self, name: String, transform: transformers::InternalTransformer) {
+    self.transforms.insert(name, transform);
+  }
+
+  pub fn build(&self, transform: String) -> TransformedToken {
+    if let Some(transformer) = self.transforms.get(&transform) {
+      let transformer_func = (transformer.get_transformer)();
+
+      return transformer_func.call(TransformedToken {
+        name: "example_token".to_string(),
+        attributes: TokenAttrs {
+          _type: None,
+          category: None,
+          item: None,
+          subitem: None,
+          state: None,
+        },
+        file_path: "path/to/file".to_string(),
+        is_source: true,
+        key: "example_key".to_string(),
+        original: serde_json::Value::Null,
+        path: vec![],
+        value: "example_value".to_string(),
+      });
+    }
+    TransformedToken {
+      name: "".to_string(),
+      attributes: TokenAttrs {
+        _type: None,
+        category: None,
+        item: None,
+        subitem: None,
+        state: None,
+      },
+      file_path: "".to_string(),
+      is_source: false,
+      key: "".to_string(),
+      original: serde_json::Value::Null,
+      path: vec![],
+      value: "".to_string(),
+    }
+  }
+}

crates/kernel/src/nephrit/transformers.rs

@@ -0,0 +1,16 @@
+use bindings::token::TransformedToken;
+
+pub enum Kind {
+  Value,
+  Name,
+}
+
+pub trait InternalTransformerCb {
+  fn call(&self, token: TransformedToken) -> TransformedToken;
+}
+
+pub struct InternalTransformer {
+  pub name: String,
+  pub kind: Kind,
+  pub get_transformer: fn() -> Box<dyn InternalTransformerCb>,
+}

index.d.ts

@@ -94,6 +94,7 @@ export declare class Nephrit {
   registerAction(action: Action): void
   registerFormat(format: Format): void
 }
+export type JsNephrit = Nephrit
 
 export interface NephriteConfig {
   source: Array<string>

index.js

@@ -574,4 +574,5 @@ if (!nativeBinding) {
 module.exports = nativeBinding
 module.exports.TransformKind = nativeBinding.TransformKind
 module.exports.Nephrit = nativeBinding.Nephrit
+module.exports.JsNephrit = nativeBinding.JsNephrit
 module.exports.NephritLogLevel = nativeBinding.NephritLogLevel

lefthook.yml

@@ -7,7 +7,8 @@ pre-commit:
   parallel: true
   jobs:
     - run: pnpm exec biome check --write {staged_files}
-      glob: "*.{js,ts,jsx,tsx}"
+      glob: "*.{ts,jsx,tsx}"
+      include: ".releaserc.js"
       exclude: "*.d.ts"
       stage_fixed: true