@bablr/helpers 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2022 Conrad Buck
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,3 @@
+## @bablr/helpers
+
+These helpers make it possible to write concise BABLR grammars.

package/lib/.babelrc.json

@@ -0,0 +1,7 @@
+{
+  "plugins": [
+    "babel-plugin-macros",
+    ["@babel/plugin-proposal-decorators", { "version": "2023-05" }],
+    ["@babel/plugin-transform-runtime", { "helpers": true, "version": "^7.22.15" }]
+  ]
+}

package/lib/decorators.js

@@ -0,0 +1 @@
+export * from '@bablr/boot-helpers/decorators';

package/lib/enhancers.js

@@ -0,0 +1,53 @@
+const { getOwnPropertyNames, hasOwn } = Object;
+
+export const memoize = (original) => {
+  const cache = new WeakMap();
+  const memoized = (...args) => {
+    if (args.length > 1) throw new Error('A memoized function accepts only one argument');
+    const arg = args[0];
+
+    if (cache.has(arg)) {
+      return cache.get(arg);
+    } else {
+      return original(arg);
+    }
+  };
+  return memoized;
+};
+
+const identity = (x) => x;
+
+export const compose = (functions) => {
+  let first = true;
+  let f = identity;
+  for (const g of functions) {
+    if (first) {
+      f = g;
+    } else {
+      const f_ = f;
+      f = (x) => f_(g(x));
+    }
+    first = false;
+  }
+
+  return f;
+};
+
+export const mapProductions = (fn, Grammar) => {
+  let { prototype } = Grammar;
+
+  class MappedGrammar extends Grammar {}
+
+  const mapped = MappedGrammar.prototype;
+
+  while (prototype) {
+    for (const key of getOwnPropertyNames(prototype)) {
+      if (!hasOwn(mapped, key)) {
+        mapped[key] = fn(prototype[key], key);
+      }
+    }
+    ({ prototype } = prototype);
+  }
+
+  return MappedGrammar;
+};

package/lib/grammar.js

@@ -0,0 +1,40 @@
+import every from 'iter-tools-es/methods/every';
+import isString from 'iter-tools-es/methods/is-string';
+import { objectEntries } from './object.js';
+
+const { isArray } = Array;
+const isSymbol = (value) => typeof value === 'symbol';
+const isType = (value) => isString(value) || isSymbol(value);
+
+export const explodeSubtypes = (aliases, exploded, types) => {
+  for (const type of types) {
+    const explodedTypes = aliases.get(type);
+    if (explodedTypes) {
+      for (const explodedType of explodedTypes) {
+        exploded.add(explodedType);
+        const subtypes = aliases.get(explodedType);
+        if (subtypes) {
+          explodeSubtypes(aliases, exploded, subtypes);
+        }
+      }
+    }
+  }
+};
+
+export const buildCovers = (rawAliases) => {
+  const aliases = new Map();
+
+  for (const alias of objectEntries(rawAliases)) {
+    if (!isType(alias[0])) throw new Error('alias[0] key must be a string or symbol');
+    if (!isArray(alias[1])) throw new Error('alias[1] must be an array');
+    if (!every(isType, alias[1])) throw new Error('alias[1] values must be strings or symbols');
+
+    aliases.set(alias[0], new Set(alias[1]));
+  }
+
+  for (const [type, types] of aliases.entries()) {
+    explodeSubtypes(aliases, aliases.get(type), types);
+  }
+
+  return new Map(aliases);
+};

package/lib/object.js

@@ -0,0 +1,48 @@
+import map from 'iter-tools-es/methods/map';
+
+export const { hasOwn, getOwnPropertySymbols, fromEntries } = Object;
+
+export const isObject = (obj) => obj !== null && typeof obj === 'object';
+export const { isArray } = Array;
+export const isFunction = (obj) => typeof obj === 'function';
+export const isSymbol = (obj) => typeof obj === 'symbol';
+export const isString = (obj) => typeof obj === 'string';
+export const isRegex = (obj) => obj instanceof RegExp;
+export const isPattern = (obj) => isString(obj) || isRegex(obj);
+export const isType = (obj) => isSymbol(obj) || isString(obj);
+
+export const objectKeys = (obj) => {
+  return {
+    *[Symbol.iterator]() {
+      for (let key in obj) if (hasOwn(obj, key)) yield key;
+      yield* getOwnPropertySymbols(obj);
+    },
+  };
+};
+
+export const objectValues = (obj) => {
+  return {
+    *[Symbol.iterator]() {
+      for (let key in obj) if (hasOwn(obj, key)) yield obj[key];
+      yield* map((sym) => obj[sym], getOwnPropertySymbols(obj));
+    },
+  };
+};
+
+export const objectEntries = (obj) => {
+  return {
+    *[Symbol.iterator]() {
+      for (let key in obj) if (hasOwn(obj, key)) yield [key, obj[key]];
+      yield* map((sym) => [sym, obj[sym]], getOwnPropertySymbols(obj));
+    },
+  };
+};
+
+export const mapObject = (fn, obj) => {
+  let result = {};
+  for (let key in obj) if (hasOwn(obj, key)) result[key] = fn(obj[key]);
+  for (const sym of getOwnPropertySymbols(obj)) result[sym] = fn(obj[sym]);
+  return result;
+};
+
+export const arrayLast = (arr) => arr[arr.length - 1];

package/lib/path.js

@@ -0,0 +1 @@
+export * from '@bablr/boot-helpers/path';

package/lib/productions.generated.js

@@ -0,0 +1,83 @@
+import { interpolateString as _interpolateString } from "@bablr/boot-helpers/template";
+import { interpolateArray as _interpolateArray } from "@bablr/boot-helpers/template";
+import * as _t from "@bablr/boot-helpers/types";
+export function* List({
+  props: {
+    element,
+    separator,
+    allowHoles = false,
+    allowTrailingSeparator = true
+  }
+}) {
+  let sep, it;
+  for (;;) {
+    it = yield _t.node("Instruction", "Call", [_t.ref`verb`, _t.ref`arguments`], {
+      verb: _t.node("Instruction", "Identifier", [_t.lit`eatMatch`], {}, {}),
+      arguments: _t.node("Instruction", "Tuple", [_t.ref`open`, _t.ref`values`, _t.ref`close`], {
+        open: _t.node("Instruction", "Punctuator", [_t.lit`(`], {}, {}),
+        values: [..._interpolateArray(element)],
+        close: _t.node("Instruction", "Punctuator", [_t.lit`)`], {}, {})
+      }, {})
+    }, {});
+    if (it || allowTrailingSeparator) {
+      sep = yield _t.node("Instruction", "Call", [_t.ref`verb`, _t.ref`arguments`], {
+        verb: _t.node("Instruction", "Identifier", [_t.lit`eatMatch`], {}, {}),
+        arguments: _t.node("Instruction", "Tuple", [_t.ref`open`, _t.ref`values`, _t.ref`close`], {
+          open: _t.node("Instruction", "Punctuator", [_t.lit`(`], {}, {}),
+          values: [..._interpolateArray(separator)],
+          close: _t.node("Instruction", "Punctuator", [_t.lit`)`], {}, {})
+        }, {})
+      }, {});
+    }
+    if (!(sep || allowHoles)) break;
+  }
+}
+export function* Any({
+  props: {
+    matchers
+  }
+}) {
+  for (const matcher of matchers) {
+    if (yield _t.node("Instruction", "Call", [_t.ref`verb`, _t.ref`arguments`], {
+      verb: _t.node("Instruction", "Identifier", [_t.lit`eatMatch`], {}, {}),
+      arguments: _t.node("Instruction", "Tuple", [_t.ref`open`, _t.ref`values`, _t.ref`close`], {
+        open: _t.node("Instruction", "Punctuator", [_t.lit`(`], {}, {}),
+        values: [..._interpolateArray(matcher)],
+        close: _t.node("Instruction", "Punctuator", [_t.lit`)`], {}, {})
+      }, {})
+    }, {})) break;
+  }
+}
+export function* All({
+  props: {
+    matchers
+  }
+}) {
+  for (const matcher of matchers) {
+    yield _t.node("Instruction", "Call", [_t.ref`verb`, _t.ref`arguments`], {
+      verb: _t.node("Instruction", "Identifier", [_t.lit`eat`], {}, {}),
+      arguments: _t.node("Instruction", "Tuple", [_t.ref`open`, _t.ref`values`, _t.ref`close`], {
+        open: _t.node("Instruction", "Punctuator", [_t.lit`(`], {}, {}),
+        values: [..._interpolateArray(matcher)],
+        close: _t.node("Instruction", "Punctuator", [_t.lit`)`], {}, {})
+      }, {})
+    }, {});
+  }
+}
+export function* Optional({
+  props: {
+    matchers
+  }
+}) {
+  if (matchers.length > 1) {
+    throw new Error('Optional only allows one matcher');
+  }
+  yield _t.node("Instruction", "Call", [_t.ref`verb`, _t.ref`arguments`], {
+    verb: _t.node("Instruction", "Identifier", [_t.lit`eatMatch`], {}, {}),
+    arguments: _t.node("Instruction", "Tuple", [_t.ref`open`, _t.ref`values`, _t.ref`close`], {
+      open: _t.node("Instruction", "Punctuator", [_t.lit`(`], {}, {}),
+      values: [..._interpolateArray(matchers[0])],
+      close: _t.node("Instruction", "Punctuator", [_t.lit`)`], {}, {})
+    }, {})
+  }, {});
+}

package/lib/productions.js

@@ -0,0 +1,33 @@
+import { i } from '@bablr/boot/shorthand.macro';
+
+export function* List({
+  props: { element, separator, allowHoles = false, allowTrailingSeparator = true },
+}) {
+  let sep, it;
+  for (;;) {
+    it = yield i`eatMatch(${element})`;
+    if (it || allowTrailingSeparator) {
+      sep = yield i`eatMatch(${separator})`;
+    }
+    if (!(sep || allowHoles)) break;
+  }
+}
+
+export function* Any({ props: { matchers } }) {
+  for (const matcher of matchers) {
+    if (yield i`eatMatch(${matcher})`) break;
+  }
+}
+
+export function* All({ props: { matchers } }) {
+  for (const matcher of matchers) {
+    yield i`eat(${matcher})`;
+  }
+}
+
+export function* Optional({ props: { matchers } }) {
+  if (matchers.length > 1) {
+    throw new Error('Optional only allows one matcher');
+  }
+  yield i`eatMatch(${matchers[0]})`;
+}

package/lib/shorthand.js

@@ -0,0 +1 @@
+export { i, re, spam } from '@bablr/boot';

package/lib/symbols.js

@@ -0,0 +1,6 @@
+export const node = Symbol.for('@bablr/node');
+
+export const active = Symbol.for('@bablr/active');
+export const suspended = Symbol.for('@bablr/suspended');
+export const accepted = Symbol.for('@bablr/accepted');
+export const rejected = Symbol.for('@bablr/rejected');

package/lib/token.js

@@ -0,0 +1,23 @@
+export const getCooked = (token) => {
+  return token.children
+    .map((child) => {
+      if (child.type === 'Escape') {
+        return child.value.cooked;
+      } else if (child.type === 'Literal') {
+        return child.value;
+      } else throw new Error();
+    })
+    .join('');
+};
+
+export const getRaw = (token) => {
+  return token.children
+    .map((child) => {
+      if (child.type === 'Escape') {
+        return child.value.raw;
+      } else if (child.type === 'Literal') {
+        return child.value;
+      } else throw new Error();
+    })
+    .join('');
+};

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@bablr/helpers",
+  "description": "Command helpers for use in writing BABLR grammars",
+  "version": "0.1.0",
+  "author": "Conrad Buck<conartist6@gmail.com>",
+  "type": "module",
+  "files": [
+    "lib"
+  ],
+  "exports": {
+    "./decorators": "./lib/decorators.js",
+    "./enhancers": "./lib/enhancers.js",
+    "./grammar": "./lib/grammar.js",
+    "./object": "./lib/object.js",
+    "./path": "./lib/path.js",
+    "./productions": "./lib/productions.generated.js",
+    "./shorthand": "./lib/shorthand.js",
+    "./symbols": "./lib/symbols.js",
+    "./token": "./lib/token.js"
+  },
+  "sideEffects": false,
+  "scripts": {
+    "generate": "babel lib/productions.js --out-file lib/productions.generated.js",
+    "clean": "rm lib/productions.generated.js"
+  },
+  "dependencies": {
+    "@bablr/boot": "0.1.1",
+    "@bablr/boot-helpers": "0.1.0",
+    "iter-tools-es": "^7.5.3"
+  },
+  "devDependencies": {
+    "@babel/cli": "7.22.15",
+    "@babel/core": "7.22.20",
+    "@babel/plugin-proposal-decorators": "7.22.15",
+    "@babel/plugin-transform-modules-commonjs": "^7.23.0",
+    "@babel/plugin-transform-runtime": "^7.22.15",
+    "@babel/runtime": "^7.23.2",
+    "@bablr/eslint-config-base": "github:bablr-lang/eslint-config-base#c040bc95f2dddac160628e4757a412016044b3ef",
+    "babel-plugin-macros": "3.1.0",
+    "enhanced-resolve": "^5.12.0",
+    "eslint": "^7.32.0",
+    "eslint-import-resolver-enhanced-resolve": "^1.0.5",
+    "eslint-plugin-import": "^2.27.5",
+    "prettier": "^2.6.2"
+  },
+  "repository": "github:bablr-lang/helpers",
+  "homepage": "https://github.com/bablr-lang/helpers",
+  "license": "MIT"
+}