mad-data-parser 0.0.1 → 0.0.2-beta.11

package/src/utils/jsonPath/guards.ts

@@ -1,37 +0,0 @@
-
-import type { BaseNode, IdentifierNode, ASTNode, NumericLiteralNode, FilterExpressionNode, ScriptExpressionNode, StringLiteralNode, WildcardNode, SliceNode, RootNode } from "./types"
-
-export function isAstNode(node: unknown): node is ASTNode {
-  return typeof node === 'object' && node !== null && 'expression' in node && typeof node.expression === 'object' && node.expression !== null && 'type' in node.expression && typeof node.expression.type === 'string'
-}
-export function isBaseNode(node: ASTNode): node is BaseNode {
-  return isAstNode(node) && 'operation' in node && typeof node.operation === 'string' && 'scope' in node && typeof node.scope === 'string'
-}
-export function isIdentifierNode(node: ASTNode): node is IdentifierNode {
-  return isBaseNode(node) && node.operation === 'member' && node.expression.type === 'identifier'
-}
-export function isNumericLiteralNode(node: ASTNode): node is NumericLiteralNode {
-  return isBaseNode(node) && node.operation === 'subscript' && node.expression.type === 'numeric_literal'
-}
-export function isFilterExpressionNode(node: ASTNode): node is FilterExpressionNode {
-  return isBaseNode(node) && node.operation === 'subscript' && node.expression.type === 'filter_expression'
-}
-export function isScriptExpressionNode(node: ASTNode): node is ScriptExpressionNode {
-  return isBaseNode(node) && node.operation === 'subscript' && node.expression.type === 'script_expression'
-}
-export function isStringLiteralNode(node: ASTNode): node is StringLiteralNode {
-  return isBaseNode(node) && node.operation === 'subscript' && node.expression.type === 'string_literal'
-}
-export function isWildcardNode(node: ASTNode): node is WildcardNode {
-  return isBaseNode(node) && node.operation === 'subscript' && node.expression.type === 'wildcard'
-}
-export function isSliceNode(node: ASTNode): node is SliceNode {
-  return isBaseNode(node) && node.operation === 'subscript' && node.expression.type === 'slice'
-}
-export function isRootNode(node: ASTNode): node is RootNode {
-  return isAstNode(node) && node.expression.type === 'root' && node.expression.value === '$'
-}
-
-export function isJSONPath(nodes: unknown): nodes is ASTNode[] {
-  return Array.isArray(nodes) && nodes.every(node => isAstNode(node))
-}

package/src/utils/jsonPath/index.ts

@@ -1,3 +0,0 @@
-export * from './types'
-export * from './guards'
-export * from './visitor'

package/src/utils/jsonPath/types.ts

@@ -1,56 +0,0 @@
-export interface ASTNode {    
-    expression: Expression
-}
-
-export type ExpressionType = 'root' | 'identifier' | 'numeric_literal' | 'filter_expression' | 'script_expression' | 'string_literal' | 'wildcard' | 'slice'
-export type ExpressionValue = string | number | undefined
-
-interface BuildExpression<T extends ExpressionType = ExpressionType, V extends ExpressionValue = ExpressionValue> {
-  type: T
-  value: V
-}
-/** expression types */
-export type Expression = BuildExpression<ExpressionType, ExpressionValue>
-export type RootExpression = BuildExpression<'root', '$'>
-export type IdentifierExpression = BuildExpression<'identifier', string>
-export type NumericLiteralExpression = BuildExpression<'numeric_literal', number>
-export type FilterExpressionExpression = BuildExpression<'filter_expression', `?(${string})`>
-export type ScriptExpressionExpression = BuildExpression<'script_expression', string>
-export type StringLiteralExpression = BuildExpression<'string_literal', string>
-export type WildcardExpression = BuildExpression<'wildcard', '*'>
-export type SliceExpression = BuildExpression<'slice', `${number|''}:${number|''}`>
-
-/** node types */
-export interface RootNode extends ASTNode {
-  expression: RootExpression
-}
-export interface BaseNode<T extends 'member' | 'subscript' = 'member'|'subscript'> extends ASTNode {
-  operation: T
-  scope: 'child' | 'descendant' | 'parent'
-}
-export interface IdentifierNode extends BaseNode<'member'> {
-  expression: IdentifierExpression
-}
-export interface NumericLiteralNode extends BaseNode<'subscript'> {
-  expression: NumericLiteralExpression
-}
-export interface FilterExpressionNode extends BaseNode<'subscript'> {
-  expression: FilterExpressionExpression
-}
-export interface ScriptExpressionNode extends BaseNode<'subscript'> {
-  expression: ScriptExpressionExpression
-}
-export interface StringLiteralNode extends BaseNode<'subscript'> {
-  expression: StringLiteralExpression
-}
-export interface WildcardNode extends BaseNode<'subscript'> {
-  expression: WildcardExpression
-}
-export interface SliceNode extends BaseNode<'subscript'> {
-  expression: SliceExpression
-}
-
-
-
-
-

package/src/utils/jsonPath/visitor.ts

@@ -1,108 +0,0 @@
-import type { ASTNode, ExpressionType, RootNode, IdentifierNode, NumericLiteralNode, FilterExpressionNode, ScriptExpressionNode, StringLiteralNode, WildcardNode, SliceNode } from "./types"
-import { isJSONPath } from "./guards"
-import { isAstNode } from "./guards"
-import { snakeToPascalCase, type SnakeToPascalCase } from "~/utils/ts/helpers"
-
-export const BREAK = Symbol('BREAK')
-
-type Kind = {
-  root: RootNode
-  identifier: IdentifierNode
-  numeric_literal: NumericLiteralNode
-  filter_expression: FilterExpressionNode
-  script_expression: ScriptExpressionNode
-  string_literal: StringLiteralNode
-  wildcard: WildcardNode
-  slice: SliceNode
-}
-
-
-/** visitor types */
-export type VisitorFn = (node: ASTNode, parent: ASTNode|null, index: Array<number>, ancestors: ASTNode[]) => ASTNode|typeof BREAK|undefined|null|void
-export type TypedVisitorFn<T extends ExpressionType = ExpressionType> = (node: Kind[T], parent: ASTNode|null, index: Array<number>, ancestors: ASTNode[]) => ASTNode|typeof BREAK|undefined|null|void
-export interface IVisitor {
-  enter?:VisitorFn;
-  leave?:VisitorFn;
-}
-export type NodeVisitor = {
-  [T in ExpressionType as `${'leave' | ''}${SnakeToPascalCase<T>}`]?: TypedVisitorFn<T>;    
-} & IVisitor
-
-function doVisit(nodes: ASTNode[]|Array<ASTNode[]>, visitor: IVisitor):void {
-  if (isJSONPath(nodes)){
-    nodes = [nodes]
-  }        
-  for (const jsonPath of nodes) {      
-    let parent: ASTNode|null = null
-    let ancestors: ASTNode[] = []
-    let path: Array<number> = []
-    for (let i = 0; i < jsonPath.length; i++) {
-      const _node = jsonPath[i]!
-      let node: ASTNode = _node  
-      path.push(i)
-      const enterResult = visitor.enter?.(node, parent, path, ancestors)
-      if(enterResult === BREAK) {
-        break
-      }
-      if(isAstNode(enterResult)) {
-        node = enterResult
-      }
-      parent = node
-      ancestors.push(node)               
-      jsonPath[i] = node        
-    }      
-    parent = ancestors.pop() ?? null
-    path.pop()
-    for (let i = jsonPath.length - 1; i >= 0; i--) {
-      const _node = jsonPath[i]!
-      let node: ASTNode = _node
-      parent = ancestors.pop() ?? null        
-      path.pop()
-      const leaveResult = visitor.leave?.(node, parent, path, ancestors)
-      if(leaveResult === BREAK) {
-        break;
-      }
-      if(isAstNode(leaveResult)) {
-        node = leaveResult
-      }
-      jsonPath[i] = node        
-    }
-  }
-}
-
-
-function makeVisitor(visitor: NodeVisitor): IVisitor {
-  const visitorCall = function (type:'enter'|'leave', ...[node, ...rest]: Parameters<TypedVisitorFn>): ReturnType<TypedVisitorFn> {
-    let result: ReturnType<TypedVisitorFn>
-    //call leave node method
-    if (type === 'leave') {
-      const methodName = `${type}${snakeToPascalCase(node.expression.type) as SnakeToPascalCase<ExpressionType>}` as keyof NodeVisitor
-      result = visitor[methodName]?.(node as any,...rest)
-      if(result === BREAK) {
-        return result
-      }
-    }
-    //call original visitor
-    if (type in visitor) {
-      result = (visitor as IVisitor)[type as keyof IVisitor]?.(node, ...rest)
-      if(result === BREAK) {
-        return result
-      }
-    }      
-    //call enter enter node method
-    if (type === 'enter') {
-      const methodName = `${snakeToPascalCase(node.expression.type) as SnakeToPascalCase<ExpressionType>}` as keyof NodeVisitor
-      result = visitor[methodName]?.(node as any,...rest)
-    }
-    return result
-  }
-  const result: IVisitor = {
-    enter: visitorCall.bind(null, 'enter') as VisitorFn,
-    leave: visitorCall.bind(null, 'leave') as VisitorFn,
-  }
-  return result
-}
-
-export function visit(nodes: ASTNode[]|Array<ASTNode[]>, visitor: NodeVisitor):void{
-  doVisit(nodes, makeVisitor(visitor))
-}

package/src/utils/ts/helpers.ts

@@ -1,13 +0,0 @@
-export type SnakeToCamelCase<S extends string> = S extends `${infer T}_${infer U}` ? 
-`${T}${Capitalize<SnakeToCamelCase<U>>}` :  S
-export type SnakeToPascalCase<S extends string> = Capitalize<SnakeToCamelCase<S>>
-
-
-export function snakeToCamelCase(str: string): SnakeToCamelCase<string> 
-{
-  return str.split('_').map(s => s.charAt(0).toUpperCase() + s.slice(1)).join('') as SnakeToCamelCase<string>
-}
-export function snakeToPascalCase(str: string): SnakeToPascalCase<string> 
-{
-  return snakeToCamelCase(str).charAt(0).toUpperCase() + snakeToCamelCase(str).slice(1) as SnakeToPascalCase<string>
-}

package/tsconfig.build.json

@@ -1,19 +0,0 @@
-{ 
-  "extends": "./tsconfig.json",    
-  "compilerOptions": {
-   "baseUrl": "./src/",
-   "rootDir": "./src/",
-   "outDir": "./dist/",
-   "paths": {
-      "~/*": [
-        "./*"
-      ]
-    }
-  },
-  "tsc-alias": {
-    "resolveFullPaths": true
-  },
-  "include": [    
-    "./src/**/*.ts",    
-  ]
-}

package/tsconfig.jest.json

@@ -1,18 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "compilerOptions": {
-    "esModuleInterop": true,
-    "noImplicitAny": false,
-    "isolatedModules": false,
-    "module": "ES2020",
-    "moduleResolution": "Bundler",
-    "verbatimModuleSyntax": true,
-    "paths": {
-      "~/*": ["./src/*"]      
-    }  
-  }, 
-  "exclude": [
-    "node_modules",
-    "dist/"
-  ]
-}

package/tsconfig.json

@@ -1,36 +0,0 @@
-{   
-  "$schema": "https://json.schemastore.org/tsconfig",
-  "extends": "@tsconfig/node20/tsconfig.json",
-  "compilerOptions": {
-    "allowImportingTsExtensions": false,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "target": "es2022",
-    "module" : "ES2020",
-    "baseUrl": "./",    
-    "allowJs": true,
-    "resolveJsonModule": true,
-    "moduleDetection": "force",
-    "moduleResolution": "Bundler",
-    "verbatimModuleSyntax": true,    
-    "strict": true,
-    "noUncheckedIndexedAccess": true,
-    "noImplicitOverride": true,    
-    "lib": ["ES2022"],
-    "outDir": "./dist",
-    "rootDir": ".",
-    "declaration": true,
-    "declarationMap": true,
-    "sourceMap": true,  
-    "types": ["node"],
-    "paths": {
-      "~/*": [
-        "./src/*"
-      ]
-    }
-  },      
-  "include": [    
-    "./src/**/*.ts",
-    "./examples/**/*.ts"
-  ]
-}