@cloudflare/util-routes 1.0.1

package/.prettierrc

@@ -0,0 +1,5 @@
+{
+  "semi": false,
+  "trailingComma": "all",
+  "singleQuote": true
+}

package/CHANGELOG.md

@@ -0,0 +1,8 @@
+# Change Log
+
+All notable changes to this project will be documented in this file.
+See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
+
+## 1.0.1 (2019-09-03)
+
+**Note:** Version bump only for package @cloudflare/util-routes

package/README.md

@@ -0,0 +1,32 @@
+# Routes utility
+
+> Wraps path-to-regexp with a convenient, type-safe tagged template function
+
+## Installation
+
+```sh
+$ npm install @cloudflare/util-workers
+```
+
+## Examples
+
+```typescript
+import { $route } from '@cloudflare/util-routes'
+
+const apiRoute = $route`/api/v4/accounts/${'accountId'}`
+
+// toUrl requires `accountId` to be passed in according to the route pattern
+apiRoute.toUrl()
+//       ^^^^^^^ Type Error: { accountId: string } is required
+
+apiRoute.toUrl({ accountId: '123' }) // => /api/v4/accounts/123
+
+// Routes can be composed
+const domainsRoute = $route`${apiRoute}/domains`
+domainsRoute.toUrl({ accountId: '123' }) // => /api/v4/accounts/123
+
+const domainRoute = $route`${domainsRoute}/${'domainName'}`
+// Now accountId and domainName are required
+// => /api/v4/accounts/123/domains/abc.com
+domainRoute.toUrl({ accountId: '123', domainName: 'abc.com' })
+```

package/es/index.js

@@ -0,0 +1 @@
+export * from './route';

package/es/route.js

@@ -0,0 +1,44 @@
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+import pathToRegExp from 'path-to-regexp';
+export var RoutePatternResult =
+/**
+ * Interperolate arguments into the route pattern
+ */
+function RoutePatternResult(pattern) {
+  _classCallCheck(this, RoutePatternResult);
+
+  _defineProperty(this, "pattern", void 0);
+
+  _defineProperty(this, "toUrl", void 0);
+
+  this.pattern = pattern;
+  this.toUrl = pathToRegExp.compile(this.pattern);
+};
+/**
+ * Tag a template string with route data
+ */
+
+export function route(strings) {
+  for (var _len = arguments.length, paramNames = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+    paramNames[_key - 1] = arguments[_key];
+  }
+
+  var pattern = strings.reduce(function (accum, str, i) {
+    var result = accum + str;
+    var paramName = paramNames[i];
+
+    if (paramName instanceof RoutePatternResult) {
+      result += paramName.pattern;
+    } else if (typeof paramName === 'string') {
+      result += ':' + paramName;
+    }
+
+    return result;
+  }, ''); // Without casting to any, we get the following error:
+  // > Type instantiation is excessively deep and possibly infinite.
+
+  return new RoutePatternResult(pattern);
+}

package/lib/index.js

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _route = require("./route");
+
+Object.keys(_route).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _route[key];
+    }
+  });
+});

package/lib/route.js

@@ -0,0 +1,58 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.route = route;
+exports.RoutePatternResult = void 0;
+
+var _pathToRegexp = _interopRequireDefault(require("path-to-regexp"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var RoutePatternResult =
+/**
+ * Interperolate arguments into the route pattern
+ */
+function RoutePatternResult(pattern) {
+  _classCallCheck(this, RoutePatternResult);
+
+  _defineProperty(this, "pattern", void 0);
+
+  _defineProperty(this, "toUrl", void 0);
+
+  this.pattern = pattern;
+  this.toUrl = _pathToRegexp.default.compile(this.pattern);
+};
+/**
+ * Tag a template string with route data
+ */
+
+
+exports.RoutePatternResult = RoutePatternResult;
+
+function route(strings) {
+  for (var _len = arguments.length, paramNames = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+    paramNames[_key - 1] = arguments[_key];
+  }
+
+  var pattern = strings.reduce(function (accum, str, i) {
+    var result = accum + str;
+    var paramName = paramNames[i];
+
+    if (paramName instanceof RoutePatternResult) {
+      result += paramName.pattern;
+    } else if (typeof paramName === 'string') {
+      result += ':' + paramName;
+    }
+
+    return result;
+  }, ''); // Without casting to any, we get the following error:
+  // > Type instantiation is excessively deep and possibly infinite.
+
+  return new RoutePatternResult(pattern);
+}

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@cloudflare/util-routes",
+  "description": "Wraps path-to-regexp with a convenient, type-safe tagged template function",
+  "version": "1.0.1",
+  "types": "./src",
+  "main": "lib/index.js",
+  "module": "es/index.js",
+  "jsnext:main": "es/index.js",
+  "author": "Frontend Team <frontend@cloudflare.com>",
+  "contributors": [
+    "John Fawcett <jfawcett@cloudflare.com",
+    "Kevin Kipp <kkipp@cloudflare.com"
+  ],
+  "license": "UNLICENSED",
+  "publishConfig": {
+    "registry": "http://registry.npmjs.org/",
+    "access": "restricted"
+  },
+  "stratus": {
+    "srcDirectory": "./src",
+    "isStandAloneApp": false,
+    "autoGeneratedReadme": false
+  },
+  "dependencies": {
+    "path-to-regexp": "^3.0.0"
+  },
+  "devDependencies": {
+    "@cloudflare/types": "^1.1.10"
+  },
+  "gitHead": "56d60ce19198f937970c3440639bca8b79258f58"
+}

package/src/index.ts

@@ -0,0 +1 @@
+export * from './route'

package/src/route.ts

@@ -0,0 +1,62 @@
+import pathToRegExp from 'path-to-regexp'
+import { ValueOfArray, Tail, Append, Head } from '@cloudflare/types'
+
+export class RoutePatternResult<Param extends string> {
+  public readonly pattern: string
+
+  /**
+   * Interperolate arguments into the route pattern
+   */
+  readonly toUrl: (
+    args: { [K in Param]: string },
+    options?: pathToRegExp.PathFunctionOptions,
+  ) => string
+
+  constructor(pattern: string) {
+    this.pattern = pattern
+    this.toUrl = pathToRegExp.compile(this.pattern)
+  }
+}
+
+/**
+ * Tag a template string with route data
+ */
+export function route<
+  Param extends string,
+  ParamOrPatternResult extends Array<Param | RoutePatternResult<string>>
+>(
+  strings: TemplateStringsArray,
+  ...paramNames: ParamOrPatternResult
+): RoutePatternResultFromParams<ParamOrPatternResult> {
+  const pattern = strings.reduce((accum, str, i) => {
+    let result = accum + str
+    const paramName = paramNames[i]
+
+    if (paramName instanceof RoutePatternResult) {
+      result += paramName.pattern
+    } else if (typeof paramName === 'string') {
+      result += ':' + paramName
+    }
+
+    return result
+  }, '')
+
+  // Without casting to any, we get the following error:
+  // > Type instantiation is excessively deep and possibly infinite.
+  return new RoutePatternResult<Param>(pattern) as any
+}
+
+type RoutePatternResultFromParams<
+  Params extends Array<string | RoutePatternResult<string>>,
+  Result extends string[] = []
+> = {
+  returnResult: RoutePatternResult<ValueOfArray<Result>>
+  recurse: RoutePatternResultFromParams<
+    Tail<Params>,
+    Append<ExtractParam<Head<Params>>, Result>
+  >
+}[Head<Params> extends never ? 'returnResult' : 'recurse']
+
+type ExtractParam<
+  T extends string | RoutePatternResult<string>
+> = T extends RoutePatternResult<infer S> ? S : T