@player-ui/player 0.3.0-next.2 → 0.3.0-next.4

package/src/binding-grammar/custom/index.ts

@@ -0,0 +1,304 @@
+import type {
+  Parser,
+  AnyNode,
+  PathNode,
+  ConcatenatedNode,
+  ValueNode,
+  QueryNode,
+  ExpressionNode,
+} from '../ast';
+import {
+  toValue,
+  toPath,
+  toConcatenatedNode,
+  toQuery,
+  toExpression,
+} from '../ast';
+
+const SEGMENT_SEPARATOR = '.';
+const OPEN_CURL = '{';
+const CLOSE_CURL = '}';
+const OPEN_BRACKET = '[';
+const CLOSE_BRACKET = ']';
+const EQUALS = '=';
+const SINGLE_QUOTE = "'";
+const DOUBLE_QUOTE = '"';
+const BACK_TICK = '`';
+// const IDENTIFIER_REGEX = /[\w\-@]+/;
+
+/** A _faster_ way to match chars instead of a regex (/[\w\-@]+/) */
+const isIdentifierChar = (char?: string): boolean => {
+  if (!char) {
+    return false;
+  }
+
+  const charCode = char.charCodeAt(0);
+
+  return (
+    (charCode >= 48 && charCode <= 57) || // 0 - 9
+    (charCode >= 65 && charCode <= 90) || // A-Z
+    (charCode >= 97 && charCode <= 122) || // a-z
+    charCode === 95 || // _
+    charCode === 45 || // -
+    charCode === 64 // @
+  );
+};
+
+/** Parse out a binding AST from a path */
+export const parse: Parser = (path) => {
+  let index = 1;
+  let ch = path.charAt(0);
+
+  /** get the next char in the string */
+  const next = (expected?: string) => {
+    if (expected && ch !== expected) {
+      throw new Error(`Expected char: ${expected} but got: ${ch}`);
+    }
+
+    ch = path.charAt(index);
+    index += 1;
+    // console.log(`Index: ${index} Char: ${ch}`);
+    return ch;
+  };
+
+  /** gobble all whitespace */
+  const whitespace = () => {
+    /* eslint-disable no-unmodified-loop-condition */
+    while (ch === ' ') {
+      next();
+    }
+  };
+
+  /** get an identifier if you can */
+  const identifier = (): ValueNode | undefined => {
+    if (!isIdentifierChar(ch)) {
+      return;
+    }
+
+    let value = ch;
+
+    while (next()) {
+      if (!isIdentifierChar(ch)) {
+        break;
+      }
+
+      value += ch;
+    }
+
+    if (value) {
+      return toValue(value);
+    }
+  };
+
+  /** get an expression node if you can */
+  const expression = (): ExpressionNode | undefined => {
+    if (ch === BACK_TICK) {
+      next(BACK_TICK);
+
+      let exp = ch;
+
+      while (next()) {
+        if (ch === BACK_TICK) {
+          break;
+        }
+
+        exp += ch;
+      }
+
+      next(BACK_TICK);
+
+      if (exp) {
+        return toExpression(exp);
+      }
+    }
+  };
+
+  /** Grab a value using a regex */
+  const regex = (match: RegExp): ValueNode | undefined => {
+    if (!ch?.match(match)) {
+      return;
+    }
+
+    let value = ch;
+
+    while (next()) {
+      if (!ch?.match(match)) {
+        break;
+      }
+
+      value += ch;
+    }
+
+    if (value) {
+      return toValue(value);
+    }
+  };
+
+  /** parse out a nestedPath if you can */
+  const nestedPath = (): PathNode | undefined => {
+    if (ch === OPEN_CURL) {
+      next(OPEN_CURL);
+      if (ch === OPEN_CURL) {
+        next(OPEN_CURL);
+
+        /* eslint-disable-next-line @typescript-eslint/no-use-before-define */
+        const modelRef = parsePath();
+        next(CLOSE_CURL);
+        next(CLOSE_CURL);
+        return modelRef;
+      }
+    }
+  };
+
+  /** get a simple segment node */
+  const simpleSegment = () => nestedPath() ?? expression() ?? identifier();
+
+  /** Parse a segment */
+  const segment = ():
+    | ConcatenatedNode
+    | PathNode
+    | ValueNode
+    | ExpressionNode
+    | undefined => {
+    // Either a string, modelRef, or concatenated version (both)
+    const segments: Array<ValueNode | PathNode | ExpressionNode> = [];
+    let nextSegment = simpleSegment();
+
+    while (nextSegment !== undefined) {
+      segments.push(nextSegment);
+      nextSegment = simpleSegment();
+    }
+
+    if (segments.length === 0) {
+      return undefined;
+    }
+
+    return toConcatenatedNode(segments);
+  };
+
+  /** get an optionally quoted block */
+  const optionallyQuotedSegment = ():
+    | ValueNode
+    | PathNode
+    | ExpressionNode
+    | undefined => {
+    whitespace();
+
+    // see if we have a quote
+
+    if (ch === SINGLE_QUOTE || ch === DOUBLE_QUOTE) {
+      const singleQuote = ch === SINGLE_QUOTE;
+      next(singleQuote ? SINGLE_QUOTE : DOUBLE_QUOTE);
+      const id = regex(/[^'"]+/);
+      next(singleQuote ? SINGLE_QUOTE : DOUBLE_QUOTE);
+      return id;
+    }
+
+    return simpleSegment();
+  };
+
+  /** eat equals signs */
+  const equals = (): boolean => {
+    if (ch !== EQUALS) {
+      return false;
+    }
+
+    while (ch === EQUALS) {
+      next();
+    }
+
+    return true;
+  };
+
+  /** Parse out a bracket */
+  const parseBracket = ():
+    | ValueNode
+    | QueryNode
+    | PathNode
+    | ExpressionNode
+    | undefined => {
+    if (ch === OPEN_BRACKET) {
+      next(OPEN_BRACKET);
+      whitespace();
+      let value: ValueNode | QueryNode | PathNode | ExpressionNode | undefined =
+        optionallyQuotedSegment();
+      if (value) {
+        whitespace();
+        if (equals()) {
+          whitespace();
+          const second = optionallyQuotedSegment();
+          value = toQuery(value, second);
+          whitespace();
+        }
+      } else {
+        throw new Error(`Expected identifier`);
+      }
+
+      if (value) {
+        next(CLOSE_BRACKET);
+      }
+
+      return value;
+    }
+  };
+
+  /** Parse a segment and any number of brackets following it */
+  const parseSegmentAndBrackets = (): Array<AnyNode> => {
+    // try to parse a segment first
+
+    const parsed = [];
+
+    const firstSegment = segment();
+
+    if (firstSegment) {
+      parsed.push(firstSegment);
+
+      let bracketSegment = parseBracket();
+
+      while (bracketSegment !== undefined) {
+        parsed.push(bracketSegment);
+        bracketSegment = parseBracket();
+      }
+    }
+
+    return parsed;
+  };
+
+  /** Parse out a path segment */
+  const parsePath = (): PathNode => {
+    const parts: AnyNode[] = [];
+
+    let nextSegment = parseSegmentAndBrackets();
+
+    while (nextSegment !== undefined) {
+      parts.push(...nextSegment);
+
+      if (!ch || ch === CLOSE_CURL) {
+        break;
+      }
+
+      if (nextSegment.length === 0 && ch) {
+        throw new Error(`Unexpected character: ${ch}`);
+      }
+
+      next(SEGMENT_SEPARATOR);
+      nextSegment = parseSegmentAndBrackets();
+    }
+
+    return toPath(parts);
+  };
+
+  try {
+    const result = parsePath();
+
+    return {
+      status: true,
+      path: result,
+    };
+  } catch (e: any) {
+    return {
+      status: false,
+      error: e.message,
+    };
+  }
+};

package/src/binding-grammar/ebnf/binding.ebnf

@@ -0,0 +1,22 @@
+value                      ::= segment_and_bracket (SEGMENT_SEPARATOR segment_and_bracket)*
+segment                    ::= concatenated | expression | modelRef | identifier  
+concatenated               ::= (expression | modelRef | identifier)+
+modelRef                   ::= OPEN_CURL OPEN_CURL value CLOSE_CURL CLOSE_CURL 
+identifier                 ::= [\\w\\-@]+
+query                      ::= WHITESPACE* optionally_quoted_segment WHITESPACE* EQUALS EQUALS? EQUALS? WHITESPACE* optionally_quoted_segment WHITESPACE*
+brackets                   ::= OPEN_BRACKET WHITESPACE* (query | optionally_quoted_segment) WHITESPACE* CLOSE_BRACKET 
+segment_and_bracket        ::= segment brackets*
+quoted_value               ::= [^"']*
+optionally_quoted_segment  ::= WHITESPACE* SINGLE_QUOTE quoted_value SINGLE_QUOTE WHITESPACE* | WHITESPACE* DOUBLE_QUOTE quoted_value DOUBLE_QUOTE WHITESPACE* | WHITESPACE* segment WHITESPACE*
+expression_value           ::= [^`]*
+expression                 ::= BACK_TICK expression_value BACK_TICK
+EQUALS                     ::= "="
+SEGMENT_SEPARATOR          ::= "."
+SINGLE_QUOTE               ::= "'"
+DOUBLE_QUOTE               ::= '"'
+WHITESPACE                 ::= " "
+OPEN_CURL                  ::= "{"
+CLOSE_CURL                 ::= "}" 
+OPEN_BRACKET               ::= "[" 
+CLOSE_BRACKET              ::= "]" 
+BACK_TICK                  ::= "`"

package/src/binding-grammar/ebnf/index.ts

@@ -0,0 +1,186 @@
+/* eslint-disable @typescript-eslint/no-use-before-define */
+import { Grammars } from 'ebnf';
+import type {
+  Parser,
+  AnyNode,
+  PathNode,
+  ValueNode,
+  ConcatenatedNode,
+  QueryNode,
+  ExpressionNode,
+} from '../ast';
+import {
+  toValue,
+  toQuery,
+  toPath,
+  toConcatenatedNode,
+  toExpression,
+} from '../ast';
+import type {
+  ValueToken,
+  ModelRefToken,
+  IdentifierToken,
+  ConcatenatedToken,
+  Token,
+  OptionallyQuotedSegment,
+  QueryToken,
+  QuotedValueToken,
+  ExpressionToken,
+} from './types';
+
+const parser = new Grammars.W3C.Parser(`
+value                      ::= segment_and_bracket (SEGMENT_SEPARATOR segment_and_bracket)*
+segment                    ::= concatenated | expression | modelRef | identifier  
+concatenated               ::= (expression | modelRef | identifier)+ 
+modelRef                   ::= OPEN_CURL OPEN_CURL value CLOSE_CURL CLOSE_CURL 
+identifier                 ::= [\\w\\-@]+
+query                      ::= WHITESPACE* optionally_quoted_segment WHITESPACE* EQUALS EQUALS? EQUALS? WHITESPACE* optionally_quoted_segment WHITESPACE*
+brackets                   ::= OPEN_BRACKET WHITESPACE* (query | optionally_quoted_segment) WHITESPACE* CLOSE_BRACKET 
+segment_and_bracket        ::= segment brackets*
+quoted_value               ::= [^"']*
+optionally_quoted_segment  ::= WHITESPACE* SINGLE_QUOTE quoted_value SINGLE_QUOTE WHITESPACE* | WHITESPACE* DOUBLE_QUOTE quoted_value DOUBLE_QUOTE WHITESPACE* | WHITESPACE* segment WHITESPACE*
+expression_value           ::= [^\`]*
+expression                 ::= BACK_TICK expression_value BACK_TICK
+
+EQUALS                     ::= "="
+SEGMENT_SEPARATOR          ::= "."
+SINGLE_QUOTE               ::= "'"
+DOUBLE_QUOTE               ::= '"'
+WHITESPACE                 ::= " "
+OPEN_CURL                  ::= "{"
+CLOSE_CURL                 ::= "}" 
+OPEN_BRACKET               ::= "[" 
+CLOSE_BRACKET              ::= "]"
+BACK_TICK                  ::= "\`" 
+`);
+
+/** Map an identifier token to a value */
+function convertIdentifierToken(token: IdentifierToken): ValueNode {
+  return toValue(token.text);
+}
+
+/** Concert an expression token into a node */
+function convertExpressionToken(token: ExpressionToken): ExpressionNode {
+  return toExpression(token.children[0].text);
+}
+
+/** map a concatenated token to a node */
+function convertConcatenatedToken(
+  token: ConcatenatedToken
+): ConcatenatedNode | ValueNode | PathNode | ExpressionNode {
+  return toConcatenatedNode(
+    token.children.map((child) => {
+      if (child.type === 'identifier') {
+        return convertIdentifierToken(child);
+      }
+
+      if (child.type === 'expression') {
+        return convertExpressionToken(child);
+      }
+
+      return convertModelRefToken(child);
+    })
+  );
+}
+
+/** map a quoted value token to a value node */
+function convertQuotedValueToken(token: QuotedValueToken): ValueNode {
+  return toValue(token.text);
+}
+
+/** map a quoted value token to a value node */
+function convertOptionallyQuotedToken(
+  token: OptionallyQuotedSegment
+): ValueNode | ConcatenatedNode | PathNode | ExpressionNode {
+  const child = token.children[0];
+  if (child.type === 'quoted_value') {
+    return convertQuotedValueToken(child);
+  }
+
+  const grandChild = child.children[0];
+  if (grandChild.type === 'identifier') {
+    return convertIdentifierToken(grandChild);
+  }
+
+  return convertConcatenatedToken(grandChild);
+}
+
+/** map a query token to a value node */
+function convertQueryToken(token: QueryToken): QueryNode {
+  return toQuery(
+    convertOptionallyQuotedToken(token.children[0]),
+    convertOptionallyQuotedToken(token.children[1])
+  );
+}
+
+/** Convert the IToken */
+function convertValueToken(binding: ValueToken): PathNode {
+  const path: AnyNode[] = [];
+
+  /** Expand a token into it's path refs */
+  function expandPath(token: Token) {
+    switch (token.type) {
+      case 'modelRef':
+        path.push(convertModelRefToken(token));
+        break;
+      case 'identifier':
+        path.push(convertIdentifierToken(token));
+        break;
+      case 'quoted_value':
+        path.push(convertQuotedValueToken(token));
+        break;
+      case 'expression':
+        path.push(convertExpressionToken(token));
+        break;
+      case 'query':
+        path.push(convertQueryToken(token));
+        break;
+      case 'concatenated':
+        path.push(convertConcatenatedToken(token));
+        break;
+      default:
+        token.children.forEach(expandPath);
+    }
+  }
+
+  expandPath(binding);
+
+  return toPath(path);
+}
+
+/** map a model ref token to a path node */
+function convertModelRefToken(token: ModelRefToken): PathNode {
+  return convertValueToken(token.children[0]);
+}
+
+/** Parse a binding using ebnf */
+export const parse: Parser = (path) => {
+  if (path === '') {
+    return {
+      status: true,
+      path: toPath([]),
+    };
+  }
+
+  const ast = parser.getAST(path) as ValueToken;
+
+  if (!ast) {
+    return {
+      status: false,
+      error: 'Unable to parse binding',
+    };
+  }
+
+  if (ast.errors.length > 0) {
+    // console.log(ast.errors);
+    return {
+      status: false,
+      error: ast.errors[0].message,
+    };
+  }
+
+  return {
+    status: true,
+    path: convertValueToken(ast),
+  };
+};

package/src/binding-grammar/ebnf/types.ts

@@ -0,0 +1,104 @@
+import type { IToken } from 'ebnf';
+
+export interface ValueToken extends IToken {
+  /** A value type  */
+  type: 'value';
+
+  /** Any children of the value */
+  children: Array<SegmentAndBracketToken>;
+}
+
+export interface SegmentAndBracketToken extends IToken {
+  /** A token for a segment + brackets */
+  type: 'segment_and_bracket';
+
+  /** The segment + brackets */
+  children: [SegmentToken, ...Array<BracketToken>];
+}
+
+export interface SegmentToken extends IToken {
+  /** A segment token */
+  type: 'segment';
+
+  /** Any children of the token */
+  children: [ConcatenatedToken | IdentifierToken];
+}
+
+export interface BracketToken extends IToken {
+  /** A bracket token */
+  type: 'bracket';
+  /** Any children of the token */
+  children: [OptionallyQuotedSegment | QueryToken];
+}
+
+export interface ExpressionValueToken extends IToken {
+  /** Expression value token */
+  type: 'expression_value';
+
+  /** No children here */
+  children: [];
+}
+
+export interface ExpressionToken extends IToken {
+  /** Expression token */
+  type: 'expression';
+
+  /** Children is the expression value */
+  children: [ExpressionValueToken];
+}
+
+export interface QuotedValueToken extends IToken {
+  /** A quoted value */
+  type: 'quoted_value';
+  /** Any children of the token */
+  children: [];
+}
+
+export interface IdentifierToken extends IToken {
+  /** Any identifier */
+  type: 'identifier';
+  /** Any children of the token */
+  children: [];
+}
+
+export interface ConcatenatedToken extends IToken {
+  /** A node of more than 1 identifier */
+  type: 'concatenated';
+  /** Any children of the token */
+  children: Array<IdentifierToken | ModelRefToken | ExpressionToken>;
+}
+
+export interface ModelRefToken extends IToken {
+  /** A nested model reference */
+  type: 'modelRef';
+  /** Any children of the token */
+  children: [ValueToken];
+}
+
+export interface OptionallyQuotedSegment extends IToken {
+  /** Any optionally quoted segment */
+  type: 'optionally_quoted_segment';
+  /** Any children of the token */
+  children: [QuotedValueToken | SegmentToken];
+}
+
+export interface QueryToken extends IToken {
+  /** A query */
+  type: 'query';
+  /** Any children of the token */
+  children: [OptionallyQuotedSegment, OptionallyQuotedSegment];
+}
+
+export type Token =
+  | ValueToken
+  | QueryToken
+  | QuotedValueToken
+  | OptionallyQuotedSegment
+  | SegmentAndBracketToken
+  | SegmentToken
+  | BracketToken
+  | IdentifierToken
+  | ConcatenatedToken
+  | ModelRefToken
+  | ExpressionValueToken
+  | ExpressionToken;

package/src/binding-grammar/index.ts

@@ -0,0 +1,4 @@
+export * from './ast';
+export { parse as parseParsimmon } from './parsimmon';
+export { parse as parseEBNF } from './ebnf';
+export { parse as parseCustom } from './custom';

package/src/binding-grammar/parsimmon/index.ts

@@ -0,0 +1,78 @@
+import flatten from 'arr-flatten';
+import type { Parser } from 'parsimmon';
+import P from 'parsimmon';
+import type { Parser as BindingParser } from '../ast';
+import {
+  toValue,
+  toConcatenatedNode,
+  toQuery,
+  toPath,
+  toExpression,
+} from '../ast';
+
+const doubleQuote = P.string('"');
+const singleQuote = P.string("'");
+const backTick = P.string('`');
+
+const identifier = P.regex(/[\w\-@]+/)
+  .desc('identifier')
+  .map(toValue);
+
+// eslint-disable-next-line prefer-const
+let path: Parser<any>;
+
+const futurePath = P.lazy(() => path);
+const nestedPath = futurePath
+  .trim(P.optWhitespace)
+  .wrap(P.string('{{'), P.string('}}'))
+  .map(toPath);
+
+const nestedExpression = P.regex(/[^`]*/)
+  .wrap(backTick, backTick)
+  .map(toExpression);
+
+const segment = P.alt(identifier, nestedPath, nestedExpression)
+  .atLeast(1)
+  .map(flatten)
+  .map(toConcatenatedNode as any);
+
+const optionallyQuotedSegment = P.alt(
+  P.regex(/[^"]*/).wrap(doubleQuote, doubleQuote).map(toValue),
+  P.regex(/[^']*/).wrap(singleQuote, singleQuote).map(toValue),
+  segment
+);
+
+const query = P.seq(
+  optionallyQuotedSegment,
+  P.string('=').times(1, 3).trim(P.optWhitespace),
+  optionallyQuotedSegment
+).map(([key, , value]) => toQuery(key as any, value as any));
+
+const brackets = P.alt(query, optionallyQuotedSegment)
+  .trim(P.optWhitespace)
+  .wrap(P.string('['), P.string(']'))
+  .many();
+
+const segmentAndBrackets = P.seqMap(segment, brackets, (s, bs) => [s, ...bs]);
+
+path = P.sepBy(segmentAndBrackets, P.string('.')).map(flatten);
+
+/** Parse a binding using parsimmon */
+export const parse: BindingParser = (binding) => {
+  const result = path.parse(binding);
+
+  if (result.status) {
+    return {
+      status: true,
+      path: {
+        name: 'PathNode',
+        path: result.value,
+      },
+    };
+  }
+
+  return {
+    status: false,
+    error: result.expected[0],
+  };
+};