toolcraft 0.0.115 → 0.0.117

package/node_modules/uri-template/dist/index.d.ts

@@ -0,0 +1,19 @@
+import * as AST from "./ast";
+export declare type RuleToNode = {
+    template: AST.Template;
+    literal: AST.Literal;
+    expression: AST.Expression;
+    operator: AST.Operator;
+    variables: AST.Variable[];
+    variable: AST.Variable;
+    listMarker: AST.ExplodeModifier;
+    substr: AST.SubstrModifier;
+    extension: string;
+};
+export declare function parse(input: string): {
+    ast: AST.Template;
+    expand: (values: Record<string, unknown>) => string;
+    toString: () => string;
+};
+export declare function parseRule<StartRule extends keyof RuleToNode>(input: string, startRule?: StartRule): RuleToNode[StartRule];
+export * from "./expander";

package/node_modules/uri-template/dist/index.js

@@ -0,0 +1,43 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+exports.__esModule = true;
+exports.parseRule = exports.parse = void 0;
+var grammar = __importStar(require("./grammar.js"));
+var AST = __importStar(require("./ast"));
+var expander_1 = require("./expander");
+function parse(input) {
+    var ast = parseRule(input, "template");
+    return {
+        ast: ast,
+        expand: function (values) { return (0, expander_1.expandTemplate)(ast, values); },
+        toString: function () { return AST.toString(ast); }
+    };
+}
+exports.parse = parse;
+function parseRule(input, startRule) {
+    if (startRule === void 0) { startRule = "template"; }
+    return grammar.parse(input, { startRule: startRule });
+}
+exports.parseRule = parseRule;
+__exportStar(require("./expander"), exports);

package/node_modules/uri-template/lib/ast.ts

@@ -0,0 +1,59 @@
+import { abort } from "process";
+
+export interface Template {
+  type: "template";
+  parts: (Literal | Expression)[];
+}
+
+export interface Literal {
+  type: "literal";
+  value: string;
+}
+
+export interface Expression {
+  type: "expression";
+  operator: Operator;
+  variables: Variable[];
+}
+
+export type Operator = "/" | ";" | "." | "?" | "&" | "+" | "#" | "";
+
+export interface Variable {
+  type: "variable";
+  name: string;
+  modifier?: SubstrModifier | ExplodeModifier;
+  extension?: string;
+}
+
+export interface ExplodeModifier {
+  type: "explode";
+}
+
+export interface SubstrModifier {
+  type: "substr";
+  length: number;
+}
+
+export function toString(
+  node: Template | Literal | Expression | Variable
+): string {
+  switch (node.type) {
+    case "template":
+      return node.parts.map(toString).join("");
+    case "literal":
+      return node.value;
+    case "expression":
+      return `{${node.operator}${node.variables.map(toString).join(",")}}`;
+    case "variable":
+      let out = node.name;
+      if (node.modifier?.type == "explode") {
+        out += "*";
+      } else if (node.modifier?.type == "substr") {
+        out += `:${node.modifier.length}`;
+      }
+      if (node.extension) {
+        out += `(${node.extension})`;
+      }
+      return out;
+  }
+}

package/node_modules/uri-template/lib/expander.ts

@@ -0,0 +1,175 @@
+import { Template, Expression, Operator, Variable } from "./ast";
+
+import pctEncode from "pct-encode";
+import { abort } from "process";
+
+const encoders = {
+  UrlSafe: pctEncode(/[^\w~.-]/g),
+  Restricted: pctEncode(/[^\w.~:\/\?#\[\]@!\$&'()*+,;=%-]|%(?!\d\d)/g),
+};
+
+export function expandTemplate(
+  ast: Template,
+  values: Record<string, unknown>
+): string {
+  const strings = ast.parts.map((part) => {
+    switch (part.type) {
+      case "literal":
+        return part.value;
+      case "expression":
+        return expandExpression(part, values);
+    }
+  });
+  return strings.join("");
+}
+
+interface ExpansionConfig {
+  first: string;
+  sep: string;
+  empty: string;
+  named: boolean;
+  encode: (s: string) => string;
+}
+
+const defaults: ExpansionConfig = {
+  first: "",
+  sep: ",",
+  empty: "",
+  encode: encoders.UrlSafe,
+  named: false,
+};
+
+const OperatorConfigs: { [op in Operator]: ExpansionConfig } = {
+  "": { ...defaults },
+  "+": { ...defaults, encode: encoders.Restricted },
+  "#": { ...defaults, encode: encoders.Restricted, first: "#", empty: "#" },
+  "/": { ...defaults, first: "/", sep: "/" },
+  ".": { ...defaults, first: ".", sep: ".", empty: "." },
+  ";": { ...defaults, first: ";", sep: ";", named: true },
+  "?": { ...defaults, first: "?", sep: "&", empty: "=", named: true },
+  "&": { ...defaults, first: "&", sep: "&", empty: "=", named: true },
+};
+
+export function expandExpression(
+  expression: Expression,
+  values: Record<string, unknown>
+): string {
+  const config = OperatorConfigs[expression.operator];
+
+  const strings: string[] = [];
+  expression.variables.forEach((variable) => {
+    const value = values[variable.name];
+    if (!present(value)) return;
+    const string = expandVariable(variable, value, config);
+    strings.push(string || "");
+  });
+  if (strings.length === 0) {
+    return "";
+  }
+  const expanded = strings.join(config.sep);
+  if (expanded.length === 0) {
+    return config.empty;
+  }
+  return config.first + expanded;
+}
+
+function expandVariable(
+  variable: Variable,
+  value: unknown,
+  config: ExpansionConfig
+): string | undefined {
+  if (value == null) {
+    throw new TypeError(
+      `tried to expand null value for variable ${variable.name}, this is a bug in uri-template`
+    );
+  }
+  if (variable.modifier?.type === "explode") {
+    return expandValueExplode(variable, value, config);
+  } else {
+    return expandValueSingle(variable, value, config);
+  }
+}
+
+function expandValueSingle(
+  variable: Variable,
+  value: unknown,
+  { empty, encode, named }: ExpansionConfig
+): string {
+  if (typeof value === "object" && variable.modifier?.type === "substr") {
+    throw new Error(
+      "Prefixed variables do not support lists/maps. Check " + variable.name
+    );
+  }
+  let out;
+  if (Array.isArray(value)) {
+    out = value.map(encode).join(",");
+  } else if (typeof value === "object") {
+    out = Object.entries(value as object)
+      .map((entry) => entry.map(encode).join(","))
+      .join(",");
+  } else {
+    out = (value as string).toString();
+    if (variable.modifier?.type === "substr") {
+      out = out.substring(0, variable.modifier.length);
+    }
+    out = encode(out);
+  }
+  if (named) {
+    if (out) {
+      out = `${variable.name}=${out}`;
+    } else {
+      out = `${variable.name}${empty}`;
+    }
+  }
+  return out;
+}
+
+function expandValueExplode(
+  variable: Variable,
+  value: unknown,
+  { encode, named, sep }: ExpansionConfig
+): string {
+  if (Array.isArray(value)) {
+    let items = value.map(encode);
+    if (named) {
+      items = items.map((item) => `${variable.name}=${item}`);
+    }
+    return items.join(sep);
+  } else if (typeof value === "object") {
+    const pairs: string[] = [];
+    Object.entries(value as object).forEach(([k, v]) => {
+      k = encode(k);
+      if (Array.isArray(v)) {
+        v.forEach((item) => {
+          pairs.push(`${k}=${encode(item)}`);
+        });
+      } else {
+        pairs.push(`${k}=${encode(v)}`);
+      }
+    });
+    return pairs.join(sep);
+  } else {
+    const s = (value as string).toString();
+    return encode(s);
+  }
+}
+
+function present(v: unknown): boolean {
+  switch (typeof v) {
+    case "undefined":
+      return false;
+    case "object":
+      if (v == null) {
+        return false;
+      }
+      if (Array.isArray(v)) {
+        return v.length > 0;
+      }
+      for (const k in v) {
+        if ((v as Record<string, unknown>)[k] != null) return true;
+      }
+      return false;
+    default:
+      return true;
+  }
+}