@matter/cli-tool 0.11.0-alpha.0-20241013-d38e934bb

package/dist/esm/domain.js

@@ -0,0 +1,178 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { BadCommandError, IncompleteError, NotACommandError, NotADirectoryError, NotFoundError } from "#errors.js";
+import { InternalError, MaybePromise } from "#general";
+import { bin, globals as defaultGlobals } from "#globals.js";
+import { Location } from "#location.js";
+import { parseInput } from "#parser.js";
+import { Directory } from "#stat.js";
+import { createContext, runInContext } from "vm";
+function Domain() {
+  const hiddenGlobals = Object.keys(globalThis);
+  const globals = Object.defineProperties(
+    {},
+    {
+      ...Object.getOwnPropertyDescriptors(globalThis),
+      ...Object.getOwnPropertyDescriptors(defaultGlobals),
+      bin: { value: { ...bin }, enumerable: true, writable: false, configurable: false }
+    }
+  );
+  globals.global = globals.globalThis = globals;
+  const domain = {
+    location: Location(
+      "",
+      globals,
+      Directory({
+        paths() {
+          const result = new Set(Object.keys(globals));
+          for (const name of hiddenGlobals) {
+            result.delete(name);
+          }
+          return [...result];
+        },
+        definitionAt(path) {
+          if (path === "crypto") {
+            return globalThis.crypto;
+          }
+          return globals[path];
+        }
+      }),
+      void 0
+    ),
+    async execute(inputStr) {
+      const input = parseInput(inputStr);
+      switch (input.kind) {
+        case "empty":
+          return;
+        case "incomplete":
+          throw new IncompleteError(input.error);
+        case "command":
+          break;
+        case "statement":
+          return await evaluate(input.js);
+        default:
+          throw new InternalError(`Unknown internal command type ${input.kind}`);
+      }
+      const { name, args } = input;
+      let location;
+      try {
+        location = await this.location.at(name);
+      } catch (e) {
+        if ((e instanceof NotFoundError || e instanceof NotADirectoryError) && name.indexOf("/") === -1) {
+          try {
+            location = await this.location.at(Location.join("/bin", name));
+          } catch (e2) {
+            if (e instanceof NotFoundError || e instanceof NotADirectoryError) {
+              throw e;
+            }
+            throw e2;
+          }
+        } else {
+          throw e;
+        }
+      }
+      const fn = location?.definition;
+      if (location === void 0 || fn === void 0) {
+        throw new NotACommandError(name);
+      }
+      if (typeof fn !== "function") {
+        if (args.length) {
+          throw new BadCommandError(name);
+        }
+        return fn;
+      }
+      const argvals = args.map((arg) => {
+        return evaluate(arg.js, {
+          lineOffset: arg.line - 1,
+          columnOffset: arg.column
+        });
+      });
+      let scope = location.parent?.definition ?? globals;
+      if (scope === globals.bin) {
+        scope = this;
+      }
+      return fn.apply(scope, argvals);
+    }
+  };
+  const context = createContext(
+    new Proxy(
+      {},
+      {
+        get(_target, key, _receiver) {
+          if (!(typeof key === "string")) {
+            return;
+          }
+          const value = domain.location.maybeAt(key);
+          if (MaybePromise.is(value)) {
+            return value.then((value2) => {
+              if (value2 === void 0) {
+                return globals[key];
+              }
+              return value2.definition;
+            });
+          }
+          if (value === void 0) {
+            return globals[key];
+          }
+          return value.definition;
+        },
+        set(target, key, newValue, _receiver) {
+          const { definition } = domain.location;
+          if (definition === void 0 || definition === null) {
+            return false;
+          }
+          target = definition;
+          target[key] = newValue;
+          return true;
+        },
+        has(_target, key) {
+          const { definition } = domain.location;
+          if (definition === void 0 || definition === null || typeof definition !== "object") {
+            return false;
+          }
+          return key in definition;
+        },
+        defineProperty(_target, property, attributes) {
+          Object.defineProperty(domain.location.definition, property, attributes);
+          return true;
+        },
+        deleteProperty(_target, property) {
+          const { definition } = domain.location;
+          if (definition === void 0 || definition === null) {
+            return false;
+          }
+          Reflect.deleteProperty(definition, property);
+          return true;
+        },
+        ownKeys(_target) {
+          return [
+            .../* @__PURE__ */ new Set([...Reflect.ownKeys(globals), ...Reflect.ownKeys(domain.location.definition)])
+          ];
+        },
+        getOwnPropertyDescriptor(_target, p) {
+          const descriptor = Reflect.getOwnPropertyDescriptor(domain.location.definition, p);
+          if (descriptor) {
+            return descriptor;
+          }
+          return Reflect.getOwnPropertyDescriptor(globals, p);
+        }
+      }
+    )
+  );
+  return domain;
+  function evaluate(js, options = {}) {
+    return runInContext(js, context, {
+      breakOnSigint: true,
+      filename: "matter-cli-eval",
+      displayErrors: false,
+      ...options
+    });
+  }
+}
+export {
+  Domain
+};
+//# sourceMappingURL=domain.js.map

package/dist/esm/domain.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../src/domain.ts"],
+  "mappings": "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",
+  "names": ["value"]
+}

package/dist/esm/errors.js

@@ -0,0 +1,54 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { MatterError } from "#general";
+class CliError extends MatterError {
+  // Error class won't be the same across vm contexts so make detection easier
+  isCliError = true;
+}
+class NotFoundError extends CliError {
+  constructor(what) {
+    super(`Not found: ${what}`);
+  }
+}
+class NotADirectoryError extends CliError {
+  constructor(what) {
+    super(`Not a directory: ${what}`);
+  }
+}
+class BadCommandError extends CliError {
+  constructor(what) {
+    super(`Bad command: ${what}`);
+  }
+}
+class NotACommandError extends CliError {
+  constructor(what) {
+    super(`Not a command: ${what}`);
+  }
+}
+class TooManyArgsError extends CliError {
+  constructor(what) {
+    super(`Too many arguments: ${what}`);
+  }
+}
+class InvalidArgumentError extends CliError {
+}
+class IncompleteError extends Error {
+  constructor(cause) {
+    super(cause.message, { cause });
+    this.cause = cause;
+  }
+}
+export {
+  BadCommandError,
+  CliError,
+  IncompleteError,
+  InvalidArgumentError,
+  NotACommandError,
+  NotADirectoryError,
+  NotFoundError,
+  TooManyArgsError
+};
+//# sourceMappingURL=errors.js.map

package/dist/esm/errors.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../src/errors.ts"],
+  "mappings": "AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,SAAS,mBAAmB;AAErB,MAAM,iBAAiB,YAAY;AAAA;AAAA,EAEtC,aAAa;AACjB;AAEO,MAAM,sBAAsB,SAAS;AAAA,EACxC,YAAY,MAAe;AACvB,UAAM,cAAc,IAAI,EAAE;AAAA,EAC9B;AACJ;AAEO,MAAM,2BAA2B,SAAS;AAAA,EAC7C,YAAY,MAAe;AACvB,UAAM,oBAAoB,IAAI,EAAE;AAAA,EACpC;AACJ;AAEO,MAAM,wBAAwB,SAAS;AAAA,EAC1C,YAAY,MAAe;AACvB,UAAM,gBAAgB,IAAI,EAAE;AAAA,EAChC;AACJ;AAEO,MAAM,yBAAyB,SAAS;AAAA,EAC3C,YAAY,MAAe;AACvB,UAAM,kBAAkB,IAAI,EAAE;AAAA,EAClC;AACJ;AAEO,MAAM,yBAAyB,SAAS;AAAA,EAC3C,YAAY,MAAc;AACtB,UAAM,uBAAuB,IAAI,EAAE;AAAA,EACvC;AACJ;AAEO,MAAM,6BAA6B,SAAS;AAAC;AAK7C,MAAM,wBAAwB,MAAM;AAAA,EACvC,YAAY,OAAc;AACtB,UAAM,MAAM,SAAS,EAAE,MAAM,CAAC;AAC9B,SAAK,QAAQ;AAAA,EACjB;AACJ;",
+  "names": []
+}

package/dist/esm/globals.js

@@ -0,0 +1,28 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import * as general from "#general";
+import * as model from "#model";
+import { Matter as matter } from "#model";
+import * as node from "#node";
+import * as protocol from "#protocol";
+import * as tools from "#tools";
+import * as types from "#types";
+const bin = {};
+const globals = {
+  general,
+  tools,
+  protocol,
+  node,
+  types,
+  matter,
+  model,
+  bin
+};
+export {
+  bin,
+  globals
+};
+//# sourceMappingURL=globals.js.map

package/dist/esm/globals.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../src/globals.ts"],
+  "mappings": "AAAA;AAAA;AAAA;AAAA;AAAA;AAOA,YAAY,aAAa;AACzB,YAAY,WAAW;AACvB,SAAS,UAAU,cAAc;AACjC,YAAY,UAAU;AACtB,YAAY,cAAc;AAC1B,YAAY,WAAW;AACvB,YAAY,WAAW;AAIhB,MAAM,MAAqC,CAAC;AAE5C,MAAM,UAAmC;AAAA,EAC5C;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACJ;",
+  "names": []
+}

package/dist/esm/location.js

@@ -0,0 +1,149 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { NotADirectoryError, NotFoundError } from "#errors.js";
+import { decamelize, MaybePromise } from "#general";
+import { Stat } from "#stat.js";
+function isClass(fn) {
+  return !Object.getOwnPropertyDescriptor(fn, "prototype")?.writable;
+}
+function Location(basename, definition, stat, parent) {
+  let { tag } = stat;
+  if (tag === void 0) {
+    if (definition === void 0) {
+      tag = "undefined";
+    } else if (typeof definition === "object") {
+      if (definition === null) {
+        tag = "null";
+      } else if (Symbol.toStringTag in definition) {
+        tag = `${definition[Symbol.toStringTag]}`;
+      } else if (Array.isArray(definition)) {
+        tag = "array";
+      } else if (ArrayBuffer.isView(definition)) {
+        tag = "bytes";
+      } else if (definition.constructor.name !== "Object") {
+        tag = definition.constructor.name;
+      } else {
+        tag = "object";
+      }
+    } else if (typeof definition === "function") {
+      if (isClass(definition)) {
+        tag = "constructor";
+      } else {
+        tag = "function";
+      }
+    } else {
+      tag = typeof definition;
+    }
+  }
+  tag = decamelize(tag);
+  return {
+    kind: typeof definition === "function" && !isClass(definition) ? "command" : stat.kind,
+    basename,
+    name: stat.name,
+    summary: stat.summary,
+    id: stat.id,
+    tag,
+    parent,
+    definition,
+    get path() {
+      if (!this.parent) {
+        return "/";
+      }
+      let path = "";
+      let location = this;
+      while (location.parent) {
+        path = `/${location.basename}${path}`;
+        location = location.parent;
+      }
+      return path;
+    },
+    get paths() {
+      if (stat.kind !== "directory") {
+        throw new NotADirectoryError(this.path);
+      }
+      return stat.paths;
+    },
+    at(path, searchedAs) {
+      const location = this.maybeAt(path);
+      if (MaybePromise.is(location)) {
+        return location.then(accept);
+      }
+      return accept(location);
+      function accept(location2) {
+        if (location2 === void 0) {
+          throw new NotFoundError(searchedAs ?? path);
+        }
+        return location2;
+      }
+    },
+    maybeAt(path, searchedAs) {
+      if (stat.kind !== "directory") {
+        throw new NotADirectoryError(searchedAs ?? path);
+      }
+      if (path === void 0 || path === "") {
+        return this;
+      }
+      const segments = path.split("/");
+      if (segments[0] === "") {
+        let location = this;
+        while (location.parent) {
+          location = location.parent;
+        }
+        return location.maybeAt(segments.slice(1).join("/"), "/");
+      }
+      while (segments[0] === "" || segments[0] === ".") {
+        searchedAs += `${segments.shift()}/`;
+      }
+      if (segments[0] === "..") {
+        return (this.parent ?? this).maybeAt(
+          segments.slice(1).join("/"),
+          searchedAs ? Location.join(searchedAs, "..") : ".."
+        );
+      }
+      if (!segments.length) {
+        return this;
+      }
+      const subsearchedAs = searchedAs ? Location.join(searchedAs, segments[0]) : segments[0];
+      const definition2 = stat.definitionAt(decodeURIComponent(segments[0]));
+      const accept = (definition3) => {
+        if (definition3 === void 0 || definition3 === null) {
+          if (segments.length > 1) {
+            throw new NotFoundError(subsearchedAs);
+          }
+          return;
+        }
+        const sublocation = Location(segments[0], definition3, Stat.of(definition3), this);
+        if (segments.length === 1) {
+          return sublocation;
+        }
+        return sublocation.at(segments.slice(1).join("/"), subsearchedAs);
+      };
+      if (MaybePromise.is(definition2)) {
+        return definition2.then(accept);
+      }
+      return accept(definition2);
+    }
+  };
+}
+((Location2) => {
+  function join(path, ...paths) {
+    for (const other of paths) {
+      if (other.startsWith("/")) {
+        path = other;
+      } else if (path.endsWith("/")) {
+        path = `${path}${other}`;
+      } else {
+        path = `${path}/${other}`;
+      }
+    }
+    return path;
+  }
+  Location2.join = join;
+})(Location || (Location = {}));
+export {
+  Location
+};
+//# sourceMappingURL=location.js.map

package/dist/esm/location.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../src/location.ts"],
+  "mappings": "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",
+  "names": ["location", "definition", "Location"]
+}

package/dist/esm/package.json

@@ -0,0 +1,12 @@
+{
+    "type": "module",
+    "imports": {
+        "#tools": "@matter/tools",
+        "#general": "@matter/general",
+        "#model": "@matter/model",
+        "#types": "@matter/types",
+        "#protocol": "@matter/protocol",
+        "#node": "@matter/node",
+        "#*": "./*"
+    }
+}

package/dist/esm/parser.js

@@ -0,0 +1,174 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { getLineInfo, parse, parseExpressionAt } from "acorn";
+import { generate } from "escodegen";
+const ACORN_PARSE_OPTIONS = {
+  ecmaVersion: "latest",
+  allowAwaitOutsideFunction: true
+};
+function parseInput(input) {
+  const inputIsCommand = isCommand(input);
+  try {
+    if (inputIsCommand) {
+      return parseCommand(input);
+    }
+    parse(input, ACORN_PARSE_OPTIONS);
+    return { kind: "statement", js: input };
+  } catch (e) {
+    if (errorIndicatesIncomplete(e, input)) {
+      return { kind: "incomplete", error: e };
+    }
+    if (!inputIsCommand) {
+      return { kind: "statement", js: input };
+    }
+    throw e;
+  }
+}
+function errorIndicatesIncomplete(e, input) {
+  if (e instanceof SyntaxError) {
+    if (e.message.startsWith("Unexpected token") && e.pos === input.length) {
+      return true;
+    }
+    if (e.message.match(/^Unterminated (?:template literal|group|comment|regular expression|template)/)) {
+      return true;
+    }
+  }
+  return false;
+}
+function parseCommand(command) {
+  let start = 0;
+  while (start < command.length && command[start].match(/\s/)) {
+    start++;
+  }
+  if (start === command.length) {
+    return { kind: "empty" };
+  }
+  const nameStart = start;
+  while (start < command.length && !command[start].match(/\s/)) {
+    start++;
+  }
+  const name = command.slice(nameStart, start);
+  const args = Array();
+  while (command.trim().length) {
+    while (start < command.length && command[start].match(/^\s/)) {
+      start++;
+    }
+    if (start === command.length) {
+      break;
+    }
+    let isExpression;
+    switch (command[start]) {
+      case "(":
+      case "[":
+      case "{":
+      case '"':
+      case "`":
+      case "'":
+        isExpression = true;
+        break;
+      default:
+        isExpression = false;
+        break;
+    }
+    const { line, column } = getLineInfo(command, start);
+    if (isExpression) {
+      try {
+        const ast = parseExpressionAt(command, start, ACORN_PARSE_OPTIONS);
+        args.push({ js: generate(ast), line, column });
+        start = ast.end;
+      } catch (e) {
+        if (e instanceof SyntaxError) {
+          let message = e.message;
+          const match = message.match(/(.*) \(\d+:\d+\)$/);
+          let location;
+          if (match) {
+            message = match[1];
+            location = message[2];
+          } else {
+            const loc = getLineInfo(command, start);
+            location = `${loc.line}:${loc.column}`;
+          }
+          const error = new SyntaxError(message);
+          error.stack = `SyntaxError: ${message}
+    at matter-cli-input:${location}`;
+          throw error;
+        }
+      }
+    } else {
+      let end = start;
+      while (end < command.length) {
+        if (command[end].match(/\s/)) {
+          break;
+        }
+        end++;
+      }
+      const str = command.slice(start, end);
+      start = end;
+      let js;
+      if (str === "true" || str === "false" || str === "NaN" || str === "Infinity" || isNumeric(str)) {
+        js = str;
+      } else {
+        js = JSON.stringify(str);
+      }
+      args.push({ js, line, column });
+    }
+  }
+  return { kind: "command", name, args };
+}
+function isCommand(input) {
+  if (input.match(isCommand.STATEMENT_DETECTOR)) {
+    return false;
+  }
+  if (input.match(isCommand.COMMAND_DETECTOR)) {
+    return true;
+  }
+  return false;
+}
+((isCommand2) => {
+  const STATEMENT_KEYWORDS = [
+    "async",
+    "break",
+    "class",
+    "const",
+    "debugger",
+    "delete",
+    "do",
+    "for",
+    "function",
+    "if",
+    "new",
+    "return",
+    "switch",
+    "throw",
+    "try",
+    "let",
+    "while",
+    "with",
+    "export",
+    "import",
+    "var",
+    "void",
+    "true",
+    "false"
+  ];
+  const IDENTIFIER = "[\\p{L}$_][\\p{L}$_0-9]*";
+  const EOW = "(?:\\s|$)";
+  const statementStarts = [...STATEMENT_KEYWORDS.map((kw) => `${kw}${EOW}`), `${IDENTIFIER}\\s*=`];
+  isCommand2.STATEMENT_DETECTOR = new RegExp(`^\\s*(?:${statementStarts.join("|")})`, "u");
+  isCommand2.COMMAND_DETECTOR = new RegExp(
+    `^\\s*(?:\\.?/)?${IDENTIFIER}(?:\\/(?:\\.?\\.|${IDENTIFIER}))*${EOW}`,
+    "u"
+  );
+})(isCommand || (isCommand = {}));
+function isNumeric(str) {
+  return !isNaN(str) && // use type coercion to parse the _entirety_ of the string (`parseFloat` alone does not do this)...
+  !isNaN(parseFloat(str));
+}
+export {
+  isCommand,
+  parseInput
+};
+//# sourceMappingURL=parser.js.map

package/dist/esm/parser.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../src/parser.ts"],
+  "mappings": "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",
+  "names": ["isCommand"]
+}

package/dist/esm/providers/endpoint.js

@@ -0,0 +1,38 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Endpoint } from "#node";
+import { Directory, Stat } from "#stat.js";
+Stat.provide((endpoint) => {
+  if (!isEndpoint(endpoint)) {
+    return;
+  }
+  return Directory({
+    definitionAt(path) {
+      const part = endpoint.parts.get(path);
+      if (part) {
+        if (!part.lifecycle.isReady) {
+          return part.construction.then(() => Stat.of(part));
+        }
+        return Stat.of(part);
+      }
+    },
+    paths() {
+      if (!endpoint.lifecycle.isPartsReady) {
+        return endpoint.construction.then(() => endpoint.parts.map((part) => part.id));
+      }
+      return endpoint.parts.map((part) => part.id);
+    }
+  });
+});
+function isEndpoint(item) {
+  return item instanceof Endpoint;
+}
+//# sourceMappingURL=endpoint.js.map