@e22m4u/js-http-static-router 0.1.2 → 0.2.1

package/src/utils/index.js

@@ -1,2 +1,10 @@
+export * from './create-error.js';
 export * from './escape-regexp.js';
+export * from './fetch-request-body.js';
+export * from './is-readable-stream.js';
+export * from './parse-content-type.js';
+export * from './create-request-mock.js';
+export * from './parse-cookie-string.js';
+export * from './create-response-mock.js';
+export * from './create-cookie-string.js';
 export * from './get-pathname-from-url.js';

package/src/utils/is-readable-stream.d.ts

@@ -0,0 +1,9 @@
+import {Readable} from 'stream';
+
+/**
+ * Check whether a value has a pipe
+ * method.
+ *
+ * @param value
+ */
+export declare function isReadableStream(value: unknown): value is Readable;

package/src/utils/is-readable-stream.js

@@ -0,0 +1,12 @@
+/**
+ * Check whether a value has a pipe method.
+ *
+ * @param {*} value
+ * @returns {boolean}
+ */
+export function isReadableStream(value) {
+  if (!value || typeof value !== 'object') {
+    return false;
+  }
+  return typeof value.pipe === 'function';
+}

package/src/utils/is-readable-stream.spec.js

@@ -0,0 +1,23 @@
+import {expect} from 'chai';
+import {Readable} from 'stream';
+import {isReadableStream} from './is-readable-stream.js';
+
+describe('isReadableStream', function () {
+  it('should return true when the value is a readable stream', function () {
+    const value1 = new Readable();
+    expect(isReadableStream(value1)).to.be.true;
+    const value2 = {pipe: () => undefined};
+    expect(isReadableStream(value2)).to.be.true;
+  });
+
+  it('should return false when the value is not a stream', function () {
+    expect(isReadableStream('string')).to.be.false;
+    expect(isReadableStream(5)).to.be.false;
+    expect(isReadableStream([])).to.be.false;
+    expect(isReadableStream({})).to.be.false;
+    expect(isReadableStream(undefined)).to.be.false;
+    expect(isReadableStream(null)).to.be.false;
+    expect(isReadableStream(NaN)).to.be.false;
+    expect(isReadableStream(() => 10)).to.be.false;
+  });
+});

package/src/utils/parse-content-type.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Parsed content type.
+ */
+export type ParsedContentType = {
+  boundary: string | undefined;
+  charset: string | undefined;
+  mediaType: string | undefined;
+};
+
+/**
+ * Parse content type.
+ *
+ * @param input
+ */
+export declare function parseContentType(input: string): ParsedContentType;

package/src/utils/parse-content-type.js

@@ -0,0 +1,34 @@
+import {InvalidArgumentError} from '@e22m4u/js-format';
+
+/**
+ * Parse content type.
+ *
+ * @param {string} input
+ * @returns {{
+ *   boundary: string|undefined,
+ *   charset: string|undefined,
+ *   mediaType: string|undefined,
+ * }}
+ */
+export function parseContentType(input) {
+  if (typeof input !== 'string') {
+    throw new InvalidArgumentError(
+      'Parameter "input" must be a String, but %v was given.',
+      input,
+    );
+  }
+  const res = {mediaType: undefined, charset: undefined, boundary: undefined};
+  const re =
+    /^\s*([^\s;/]+\/[^\s;/]+)(?:;\s*charset=([^\s;]+))?(?:;\s*boundary=([^\s;]+))?.*$/i;
+  const matches = re.exec(input);
+  if (matches && matches[1]) {
+    res.mediaType = matches[1];
+    if (matches[2]) {
+      res.charset = matches[2];
+    }
+    if (matches[3]) {
+      res.boundary = matches[3];
+    }
+  }
+  return res;
+}

package/src/utils/parse-content-type.spec.js

@@ -0,0 +1,79 @@
+import {expect} from 'chai';
+import {format} from '@e22m4u/js-format';
+import {parseContentType} from './parse-content-type.js';
+
+describe('parseContentType', function () {
+  it('should require the parameter "input" to be a String', function () {
+    const throwable = v => () => parseContentType(v);
+    const error = s =>
+      format('Parameter "input" must be a String, but %s was given.', s);
+    expect(throwable(10)).to.throw(error('10'));
+    expect(throwable(0)).to.throw(error('0'));
+    expect(throwable(true)).to.throw(error('true'));
+    expect(throwable(false)).to.throw(error('false'));
+    expect(throwable([])).to.throw(error('Array'));
+    expect(throwable({})).to.throw(error('Object'));
+    expect(throwable(undefined)).to.throw(error('undefined'));
+    expect(throwable(null)).to.throw(error('null'));
+    expect(throwable(() => undefined)).to.throw(error('Function'));
+    throwable('text/html')();
+  });
+
+  it('should return the object with specific properties', function () {
+    const res = parseContentType('');
+    expect(res).to.be.eql({
+      mediaType: undefined,
+      charset: undefined,
+      boundary: undefined,
+    });
+  });
+
+  it('should parse the media type from the given string', function () {
+    const res1 = parseContentType('text/html');
+    expect(res1).to.be.eql({
+      mediaType: 'text/html',
+      charset: undefined,
+      boundary: undefined,
+    });
+    const res2 = parseContentType('text/html;');
+    expect(res2).to.be.eql({
+      mediaType: 'text/html',
+      charset: undefined,
+      boundary: undefined,
+    });
+  });
+
+  it('should parse the media type with charset', function () {
+    const res1 = parseContentType('text/html; charset=utf-8');
+    expect(res1).to.be.eql({
+      mediaType: 'text/html',
+      charset: 'utf-8',
+      boundary: undefined,
+    });
+    const res2 = parseContentType('text/html; charset=utf-8;');
+    expect(res2).to.be.eql({
+      mediaType: 'text/html',
+      charset: 'utf-8',
+      boundary: undefined,
+    });
+  });
+
+  it('should parse the media type with boundary', function () {
+    const res1 = parseContentType(
+      'multipart/form-data; boundary=---WebKitFormBoundary7MA4YWxkTrZu0gW',
+    );
+    expect(res1).to.be.eql({
+      mediaType: 'multipart/form-data',
+      charset: undefined,
+      boundary: '---WebKitFormBoundary7MA4YWxkTrZu0gW',
+    });
+    const res2 = parseContentType(
+      'multipart/form-data; boundary=---WebKitFormBoundary7MA4YWxkTrZu0gW;',
+    );
+    expect(res2).to.be.eql({
+      mediaType: 'multipart/form-data',
+      charset: undefined,
+      boundary: '---WebKitFormBoundary7MA4YWxkTrZu0gW',
+    });
+  });
+});

package/src/utils/parse-cookie-string.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Parsed cookies.
+ */
+type ParsedCookies = {
+  [key: string]: string | undefined;
+};
+
+/**
+ * Parse cookie string.
+ *
+ * @example
+ * ```ts
+ * parseCookieString('pkg=math; equation=E%3Dmc%5E2');
+ * // {pkg: 'math', equation: 'E=mc^2'}
+ * ```
+ *
+ * @param input
+ */
+export declare function parseCookieString(input: string): ParsedCookies;

package/src/utils/parse-cookie-string.js

@@ -0,0 +1,36 @@
+import {InvalidArgumentError} from '@e22m4u/js-format';
+
+/**
+ * Parse cookie string.
+ *
+ * @example
+ * ```ts
+ * parseCookieString('pkg=math; equation=E%3Dmc%5E2');
+ * // {pkg: 'math', equation: 'E=mc^2'}
+ * ```
+ *
+ * @param {string} input
+ * @returns {object}
+ */
+export function parseCookieString(input) {
+  if (typeof input !== 'string') {
+    throw new InvalidArgumentError(
+      'Parameter "input" must be a String, but %v was given.',
+      input,
+    );
+  }
+  return input
+    .split(';')
+    .filter(v => v !== '')
+    .map(v => v.split('='))
+    .reduce((cookies, tuple) => {
+      const key = decodeURIComponent(tuple[0]).trim();
+      if (key === '__proto__' || key === 'constructor' || key === 'prototype') {
+        return cookies;
+      }
+      const value =
+        tuple[1] !== undefined ? decodeURIComponent(tuple[1]).trim() : '';
+      cookies[key] = value;
+      return cookies;
+    }, {});
+}

package/src/utils/parse-cookie-string.spec.js

@@ -0,0 +1,45 @@
+import {expect} from 'chai';
+import {format} from '@e22m4u/js-format';
+import {parseCookieString} from './parse-cookie-string.js';
+
+describe('parseCookieString', function () {
+  it('should require the parameter "input" to be a String', function () {
+    const throwable = v => () => parseCookieString(v);
+    const error = v =>
+      format('Parameter "input" must be a String, but %s was given.', v);
+    expect(throwable(10)).to.throw(error('10'));
+    expect(throwable(0)).to.throw(error('0'));
+    expect(throwable(true)).to.throw(error('true'));
+    expect(throwable(false)).to.throw(error('false'));
+    expect(throwable(null)).to.throw(error('null'));
+    expect(throwable({})).to.throw(error('Object'));
+    expect(throwable([])).to.throw(error('Array'));
+    expect(throwable(undefined)).to.throw(error('undefined'));
+    throwable('str')();
+    throwable('')();
+  });
+
+  it('should return cookies as a plain object', function () {
+    const value = 'pkg=math; equation=E%3Dmc%5E2';
+    const result = parseCookieString(value);
+    expect(result).to.have.property('pkg', 'math');
+    expect(result).to.have.property('equation', 'E=mc^2');
+  });
+
+  it('should return an empty object for an empty string', function () {
+    const result = parseCookieString('');
+    expect(result).to.be.eql({});
+  });
+
+  it('should parse an empty cookie as an empty string', function () {
+    const result = parseCookieString('foo=bar; baz');
+    expect(result).to.be.eql({foo: 'bar', baz: ''});
+  });
+
+  it('should ignore prototype properties', function () {
+    const result = parseCookieString(
+      '__proto__=a; constructor=b; prototype=c; foo=bar',
+    );
+    expect(result).to.be.eql({foo: 'bar'});
+  });
+});

package/{example/static → static}/index.html

@@ -1,10 +1,10 @@
 <!DOCTYPE html>
 <html>
 <head>
-    <title>Index Page</title>
+    <title>Home</title>
 </head>
 <body>
-    <h1>Index Page</h1>
+    <h1>Home</h1>
     <p>at /static/index.html</p>
 </body>
 </html>