mqtt-pattern 1.1.3 → 2.0.0

package/.eslintrc

@@ -1,30 +1,30 @@
-{
-  "extends": [
-    "eslint:recommended",
-    "plugin:node/recommended"
-  ],
-  "env": {},
-  "globals": {
-    "window": true
-  },
-  "plugins": [
-    "node"
-  ],
-  "rules": {
-    "no-undef": 2,
-    "no-unused-vars": 2,
-    "strict": [2, "global"],
-    "new-cap": 0,
-    "indent": ["error", "tab", {"MemberExpression": 1, "ArrayExpression": 1, "ObjectExpression": 1 }],
-    "no-console": 0,
-    "no-invalid-this": 0,
-    "node/no-missing-require": 1,
-    "no-trailing-spaces": 2,
-    "semi": ["error", "always"],
-    "key-spacing": ["warn", { "beforeColon": false, "afterColon": true }],
-    "space-infix-ops": ["warn"],
-    "object-curly-newline": ["warn", {"minProperties": 1}],
-    "no-shadow": ["error"],
-    "no-undef-init": ["error"]
-  }
-}
+{
+  "extends": [
+    "eslint:recommended",
+    "plugin:node/recommended"
+  ],
+  "env": {},
+  "globals": {
+    "window": true
+  },
+  "plugins": [
+    "node"
+  ],
+  "rules": {
+    "no-undef": 2,
+    "no-unused-vars": 2,
+    "strict": [2, "global"],
+    "new-cap": 0,
+    "indent": ["error", "tab", {"MemberExpression": 1, "ArrayExpression": 1, "ObjectExpression": 1 }],
+    "no-console": 0,
+    "no-invalid-this": 0,
+    "node/no-missing-require": 1,
+    "no-trailing-spaces": 2,
+    "semi": ["error", "always"],
+    "key-spacing": ["warn", { "beforeColon": false, "afterColon": true }],
+    "space-infix-ops": ["warn"],
+    "object-curly-newline": ["warn", {"minProperties": 1}],
+    "no-shadow": ["error"],
+    "no-undef-init": ["error"]
+  }
+}

package/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2017 
-
-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.
+MIT License
+
+Copyright (c) 2017 
+
+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

@@ -1,78 +1,84 @@
-# mqtt-pattern
-Fast library for matching MQTT patterns with named wildcards to extract data from topics
-
-Successor to [mqtt-regex](./mqtt-regex)
-
-## Example:
-
-``` javascript
-var MQTTPattern = require("mqtt-pattern");
-
-// Wildcards in patterns don't need names
-var pattern = "device/+id/+/#data";
-
-var topic = "device/fitbit/heartrate/rate/bpm";
-
-var params = MQTTPattern.exec(pattern, topic);
-
-// params will be
-{
-	id: "fitbit",
-	data: ["rate", "bmp"]
-}
-
-var filled = MQTTPattern.fill(pattern, params);
-// filled will be
-"device/fitbit/undefined/rate/bmp"
-
-```
-
-## Installing
-
-With NPM:
-
-```bash
-npm install --save mqtt-pattern
-```
-
-## API
-
-### `exec(pattern : String, topic : String) : Object | null`
-Validates that `topic` fits the `pattern` and parses out any parameters.
-If the topic doesn't match, it returns `null`
-
-### `matches(pattern : String, topic : String) : Boolean`
-Validates whether `topic` fits the `pattern`. Ignores parameters.
-
-### `extract(pattern : String, topic : String) : Object`
-Traverses the `pattern` and attempts to fetch parameters from the `topic`.
-Useful if you know in advance that your `topic` will be valid and want to extract data.
-If the `topic` doesn't match, or the `pattern` doesn't contain named wildcards, returns an empty object.
-Do not use this for validation.
-
-### `fill(pattern : String, params: Object) : String`
-Reverse of `extract`, traverse the `pattern` and fill in params with keys in an object. Missing keys for `+` params are set to `undefined`. Missing keys for `#` params yeid empty strings.
-
-## How params work
-
-MQTT defines two types of "wildcards", one for matching a single section of the path (`+`), and one for zero or more sections of the path (`#`).
-Note that the `#` wildcard must only be used if it's at the end of the topic.
-This library was inspired by the syntax in the routers for web frameworks.
-
-### Examples of topic patterns:
-
-#### user/+id/#path
-This would match paths that start with `user/`, and then extract the next section as the user `id`.
-Then it would get the following paths and turn them into an array for the `path` param.
-Here is some input/output that you can expect:
-
-	user/bob/status/mood: {id: "bob", path:["status","mood"]
-	user/bob: {id:"bob", path: []}
-	user/bob/ishungry: {id: "bob", path: ["ishungry"]
-
-#### device/+/+/component/+type/#path
-Not all wildcards need to be associated with a parameter, and it could be useful to use plain MQTT topics.
-In this example you might only care about the status of some part of a device, and are willing to ignore a part of the path.
-Here are some examples of what this might be used with:
-
-	device/deviceversion/deviceidhere/component/infrared/status/active: {type:"infrared",path: ["status","active"]}
+# mqtt-pattern
+Fast library for matching MQTT patterns with named wildcards to extract data from topics
+
+Successor to [mqtt-regex](./mqtt-regex)
+
+## Example:
+
+``` javascript
+var MQTTPattern = require("mqtt-pattern");
+
+// Wildcards in patterns don't need names
+var pattern = "device/+id/+/#data";
+
+var topic = "device/fitbit/heartrate/rate/bpm";
+
+var params = MQTTPattern.exec(pattern, topic);
+
+// params will be
+{
+	id: "fitbit",
+	data: ["rate", "bmp"]
+}
+
+var filled = MQTTPattern.fill(pattern, params);
+// filled will be
+"device/fitbit/undefined/rate/bmp"
+
+MQTTPattern.clean("hello/+param1/world/#param2");
+// hello/+/world/#
+
+```
+
+## Installing
+
+With NPM:
+
+```bash
+npm install --save mqtt-pattern
+```
+
+## API
+
+### `exec(pattern : String, topic : String) : Object | null`
+Validates that `topic` fits the `pattern` and parses out any parameters.
+If the topic doesn't match, it returns `null`
+
+### `matches(pattern : String, topic : String) : Boolean`
+Validates whether `topic` fits the `pattern`. Ignores parameters.
+
+### `extract(pattern : String, topic : String) : Object`
+Traverses the `pattern` and attempts to fetch parameters from the `topic`.
+Useful if you know in advance that your `topic` will be valid and want to extract data.
+If the `topic` doesn't match, or the `pattern` doesn't contain named wildcards, returns an empty object.
+Do not use this for validation.
+
+### `fill(pattern : String, params: Object) : String`
+Reverse of `extract`, traverse the `pattern` and fill in params with keys in an object. Missing keys for `+` params are set to `undefined`. Missing keys for `#` params yeid empty strings.
+
+### `clean(pattern : String) : String`
+Removes the parameter names from a pattern.
+
+## How params work
+
+MQTT defines two types of "wildcards", one for matching a single section of the path (`+`), and one for zero or more sections of the path (`#`).
+Note that the `#` wildcard must only be used if it's at the end of the topic.
+This library was inspired by the syntax in the routers for web frameworks.
+
+### Examples of topic patterns:
+
+#### user/+id/#path
+This would match paths that start with `user/`, and then extract the next section as the user `id`.
+Then it would get the following paths and turn them into an array for the `path` param.
+Here is some input/output that you can expect:
+
+	user/bob/status/mood: {id: "bob", path:["status","mood"]
+	user/bob: {id:"bob", path: []}
+	user/bob/ishungry: {id: "bob", path: ["ishungry"]
+
+#### device/+/+/component/+type/#path
+Not all wildcards need to be associated with a parameter, and it could be useful to use plain MQTT topics.
+In this example you might only care about the status of some part of a device, and are willing to ignore a part of the path.
+Here are some examples of what this might be used with:
+
+	device/deviceversion/deviceidhere/component/infrared/status/active: {type:"infrared",path: ["status","active"]}

package/index.d.ts

@@ -0,0 +1,58 @@
+import type { MqttParameters, FillTopic, CleanTopic } from "./parameters";
+import type { F } from "ts-toolbelt";
+
+/**
+ * Extract parameters from a topic based on the pattern provided
+ * @param pattern Pattern to match against
+ * @param topic Topic to extract parameters from
+ */
+export declare function exec<Pattern extends string>(
+  pattern: Pattern,
+  topic: string
+): MqttParameters<Pattern> | null;
+
+/**
+ * Tests if a topic is valid for a certain pattern.
+ * @param pattern Pattern to match against
+ * @param topic Topic to test
+ */
+export declare function matches(pattern: string, topic: string): boolean;
+
+/**
+ * Take a pattern and fill the parameters with the appropriate values
+ * @param pattern Pattern to fill
+ * @param params Parameters to insert into the pattern
+ */
+export declare function fill<
+  Pattern extends string,
+  Params extends MqttParameters<Pattern>
+>(
+  pattern: F.Narrow<Pattern>,
+  params: F.Narrow<Params>
+): FillTopic<Pattern, Params>;
+
+/**
+ * Extract parameter values from a topic using a pattern.
+ *
+ * This function doesn't check if the pattern matches before attempting
+ * extraction, @see exec if you want to extract values, with assurances that the
+ * topic actually matches the pattern..
+ *
+ * @deprecated use exec for safety on topic matching the pattern
+ * @param pattern Pattern to extract using
+ * @param topic Topic to extract values from
+ */
+export declare function extract<Pattern extends string>(
+  pattern: Pattern,
+  topic: string
+): MqttParameters<Pattern>;
+
+/**
+ * Clean a pattern (remove any property names from wildcard segments)
+ *
+ * @param pattern Pattern to clean
+ * @returns cleaned pattern safe for usage in subscriptions etc.
+ */
+export declare function clean<Pattern extends string>(
+  pattern: Pattern
+): CleanTopic<Pattern>;

package/index.js

@@ -1,97 +1,121 @@
-"use strict";
-var SEPARATOR = "/";
-var SINGLE = "+";
-var ALL = "#";
-
-module.exports = {
-	matches: matches,
-	extract: extract,
-	exec: exec,
-	fill: fill,
-};
-
-function exec(pattern, topic) {
-	return matches(pattern, topic) ? extract(pattern, topic) : null;
-}
-
-function matches(pattern, topic) {
-	var patternSegments = pattern.split(SEPARATOR);
-	var topicSegments = topic.split(SEPARATOR);
-
-	var patternLength = patternSegments.length;
-	var topicLength = topicSegments.length;
-	var lastIndex = patternLength - 1;
-
-	for(var i = 0; i < patternLength; i++){
-		var currentPattern = patternSegments[i];
-		var patternChar = currentPattern[0];
-		var currentTopic = topicSegments[i];
-
-		if(!currentTopic && !currentPattern)
-			continue;
-
-		if(!currentTopic && currentPattern !== ALL) return false;
-
-		// Only allow # at end
-		if(patternChar === ALL)
-			return i === lastIndex;
-		if(patternChar !== SINGLE && currentPattern !== currentTopic)
-			return false;
-	}
-
-	return patternLength === topicLength;
-}
-
-function fill(pattern, params){
-	var patternSegments = pattern.split(SEPARATOR);
-	var patternLength = patternSegments.length;
-
-	var result = [];
-
-	for (var i = 0; i < patternLength; i++) {
-		var currentPattern = patternSegments[i];
-		var patternChar = currentPattern[0];
-		var patternParam = currentPattern.slice(1);
-		var paramValue = params[patternParam];
-
-		if(patternChar === ALL){
-			// Check that it isn't undefined
-			if(paramValue !== void 0)
-				result.push([].concat(paramValue).join(SEPARATOR)); // Ensure it's an array
-
-			// Since # wildcards are always at the end, break out of the loop
-			break;
-		} else if (patternChar === SINGLE)
-			// Coerce param into a string, missing params will be undefined
-			result.push("" + paramValue);
-		else result.push(currentPattern);
-	}
-
-	return result.join(SEPARATOR);
-}
-
-
-function extract(pattern, topic) {
-	var params = {};
-	var patternSegments = pattern.split(SEPARATOR);
-	var topicSegments = topic.split(SEPARATOR);
-
-	var patternLength = patternSegments.length;
-
-	for(var i = 0; i < patternLength; i++){
-		var currentPattern = patternSegments[i];
-		var patternChar = currentPattern[0];
-
-		if(currentPattern.length === 1)
-			continue;
-
-		if(patternChar === ALL){
-			params[currentPattern.slice(1)] = topicSegments.slice(i);
-			break;
-		} else if(patternChar === SINGLE){
-			params[currentPattern.slice(1)] = topicSegments[i];
-		}
-	}
-
-	return params;
-}
+"use strict";
+var SEPARATOR = "/";
+var SINGLE = "+";
+var ALL = "#";
+
+module.exports = {
+	matches: matches,
+	extract: extract,
+	exec: exec,
+	fill: fill,
+	clean: clean
+};
+
+function exec(pattern, topic) {
+	return matches(pattern, topic) ? extract(pattern, topic) : null;
+}
+
+function matches(pattern, topic) {
+	var patternSegments = pattern.split(SEPARATOR);
+	var topicSegments = topic.split(SEPARATOR);
+
+	var patternLength = patternSegments.length;
+	var topicLength = topicSegments.length;
+	var lastIndex = patternLength - 1;
+
+	for(var i = 0; i < patternLength; i++){
+		var currentPattern = patternSegments[i];
+		var patternChar = currentPattern[0];
+		var currentTopic = topicSegments[i];
+
+		if(!currentTopic && !currentPattern)
+			continue;
+
+		if(!currentTopic && currentPattern !== ALL) return false;
+
+		// Only allow # at end
+		if(patternChar === ALL)
+			return i === lastIndex;
+		if(patternChar !== SINGLE && currentPattern !== currentTopic)
+			return false;
+	}
+
+	return patternLength === topicLength;
+}
+
+function fill(pattern, params){
+	var patternSegments = pattern.split(SEPARATOR);
+	var patternLength = patternSegments.length;
+
+	var result = [];
+
+	for (var i = 0; i < patternLength; i++) {
+		var currentPattern = patternSegments[i];
+		var patternChar = currentPattern[0];
+		var patternParam = currentPattern.slice(1);
+		var paramValue = params[patternParam];
+
+		if(patternChar === ALL){
+			// Check that it isn't undefined
+			if(paramValue !== void 0)
+				result.push([].concat(paramValue).join(SEPARATOR)); // Ensure it's an array
+
+			// Since # wildcards are always at the end, break out of the loop
+			break;
+		} else if (patternChar === SINGLE)
+			// Coerce param into a string, missing params will be undefined
+			result.push("" + paramValue);
+		else result.push(currentPattern);
+	}
+
+	return result.join(SEPARATOR);
+}
+
+
+function extract(pattern, topic) {
+	var params = {};
+	var patternSegments = pattern.split(SEPARATOR);
+	var topicSegments = topic.split(SEPARATOR);
+
+	var patternLength = patternSegments.length;
+
+	for(var i = 0; i < patternLength; i++){
+		var currentPattern = patternSegments[i];
+		var patternChar = currentPattern[0];
+
+		if(currentPattern.length === 1)
+			continue;
+
+		if(patternChar === ALL){
+			params[currentPattern.slice(1)] = topicSegments.slice(i);
+			break;
+		} else if(patternChar === SINGLE){
+			params[currentPattern.slice(1)] = topicSegments[i];
+		}
+	}
+
+	return params;
+}
+
+
+function clean(pattern) {
+	var patternSegments = pattern.split(SEPARATOR);
+	var patternLength = patternSegments.length;
+
+	var cleanedSegments = [];
+
+	for(var i = 0; i < patternLength; i++){
+		var currentPattern = patternSegments[i];
+		var patternChar = currentPattern[0];
+
+		if(patternChar === ALL){
+			cleanedSegments.push(ALL);
+		} else if(patternChar === SINGLE){
+			cleanedSegments.push(SINGLE);
+		} else {
+			cleanedSegments.push(currentPattern);
+		}
+	}
+
+	return cleanedSegments.join('/');
+}

package/package.json

@@ -1,33 +1,35 @@
-{
-  "name": "mqtt-pattern",
-  "version": "1.1.3",
-  "description": "Fast library for matching MQTT patterns with named wildcards",
-  "main": "index.js",
-  "scripts": {
-    "test": "node test"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/RangerMauve/mqtt-pattern.git"
-  },
-  "keywords": [
-    "mqtt",
-    "pattern",
-    "match",
-    "topic"
-  ],
-  "author": "rangermauve",
-  "license": "MIT",
-  "bugs": {
-    "url": "https://github.com/RangerMauve/mqtt-pattern/issues"
-  },
-  "homepage": "https://github.com/RangerMauve/mqtt-pattern#readme",
-  "devDependencies": {
-    "eslint": "^3.19.0",
-    "eslint-plugin-node": "^4.2.2",
-    "tape": "^4.6.3"
-  },
-  "dependencies": {
-    "mqtt-match": "^1.0.2"
-  }
-}
+{
+  "name": "mqtt-pattern",
+  "version": "2.0.0",
+  "description": "Fast library for matching MQTT patterns with named wildcards",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "scripts": {
+    "test": "node test"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/RangerMauve/mqtt-pattern.git"
+  },
+  "keywords": [
+    "mqtt",
+    "pattern",
+    "match",
+    "topic"
+  ],
+  "author": "rangermauve",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/RangerMauve/mqtt-pattern/issues"
+  },
+  "homepage": "https://github.com/RangerMauve/mqtt-pattern#readme",
+  "devDependencies": {
+    "eslint": "^3.19.0",
+    "eslint-plugin-node": "^4.2.2",
+    "tape": "^4.6.3",
+    "ts-toolbelt": "^9.6.0"
+  },
+  "dependencies": {
+    "mqtt-match": "^1.0.2"
+  }
+}

package/parameters.d.ts

@@ -0,0 +1,90 @@
+/** This code is copied from the typings in @erichardson-lee/mqtt-router */
+
+//#region Topic Parameter name & type inference
+
+/** Check if a string is a parameter in a type */
+type IsParameter<Parameter> = Parameter extends `+${infer ParamName}`
+  ? ParamName
+  : never | Parameter extends `#${string}`
+  ? Parameter
+  : never;
+
+/** Type To split by / and extract parameters */
+type FilteredTopicSplit<Topic> = Topic extends `${infer PartA}/${infer PartB}`
+  ? IsParameter<PartA> | FilteredTopicSplit<PartB>
+  : IsParameter<Topic>;
+
+/** Type to get Parameter Value */
+type ParameterValue<Parameter> = Parameter extends `#${string}`
+  ? string[]
+  : string;
+
+/** Type to remove # prefix from parameter */
+type StripParameterHash<Parameter> = Parameter extends `#${infer Name}`
+  ? Name
+  : Parameter;
+
+/** Parameter Type */
+export type MqttParameters<Topic> = {
+  [key in FilteredTopicSplit<Topic> as StripParameterHash<key>]: ParameterValue<key>;
+};
+//#endregion
+
+//#region Topic Cleaning
+
+/** Clean a segment of a Topic */
+type CleanTopicSegment<Segment> = Segment extends `+${string}`
+  ? "+"
+  : Segment extends `#${string}`
+  ? "#"
+  : Segment;
+
+/** Clean a Topic (replace #value or +value with # or + respectively) */
+export type CleanTopic<Topic> = Topic extends `${infer PartA}/${infer PartB}`
+  ? `${CleanTopicSegment<PartA>}/${CleanTopic<PartB>}`
+  : CleanTopicSegment<Topic>;
+
+//#endregion
+
+//#region Topic Filling
+type JoinPath<Parts extends string[]> = Parts extends [infer v, ...infer rest]
+  ? rest extends []
+    ? v
+    : v extends string
+    ? rest extends string[]
+      ? `${v}/${JoinPath<rest>}`
+      : ""
+    : ""
+  : "";
+
+type FillParam<
+  Section extends string,
+  Parameters extends MqttParameters<FullPattern>,
+  FullPattern extends string = Section
+> = Section extends `+${infer PName}`
+  ? PName extends keyof Parameters
+    ? Parameters[PName] extends string
+      ? Parameters[PName]
+      : unknown
+    : unknown
+  : Section extends `#${infer PName}`
+  ? PName extends keyof Parameters
+    ? Parameters[PName] extends string[]
+      ? JoinPath<Parameters[PName]>
+      : unknown
+    : unknown
+  : Section;
+
+export type FillTopic<
+  Pattern extends string,
+  Parameters extends MqttParameters<FullPattern>,
+  FullPattern extends string = Pattern
+> = Pattern extends `${infer Left}/${infer Right}`
+  ? `${FillParam<Left, Parameters, FullPattern>}/${FillTopic<
+      Right,
+      Parameters,
+      FullPattern
+    >}`
+  : FillParam<Pattern, Parameters, FullPattern>;
+
+//#endregion

package/test.js

@@ -1,157 +1,167 @@
-"use strict";
-
-var test = require("tape");
-
-var MQTTPattern = require("./");
-
-test("matches() supports patterns with no wildcards", function (t) {
-	t.plan(1);
-	t.ok(MQTTPattern.matches("foo/bar/baz", "foo/bar/baz"), "Matched topic");
-});
-
-test("matches() doesn't match different topics", function (t) {
-	t.plan(1);
-	t.notOk(MQTTPattern.matches("foo/bar/baz", "baz/bar/foo"), "Didn't match topic");
-});
-
-test("matches() supports patterns with # at the beginning", function (t) {
-	t.plan(1);
-	t.ok(MQTTPattern.matches("#", "foo/bar/baz"), "Matched topic");
-});
-
-test("matches() supports patterns with # at the end", function (t) {
-	t.plan(1);
-	t.ok(MQTTPattern.matches("foo/#", "foo/bar/baz"), "Matched topic");
-});
-
-test("matches() supports patterns with # at the end and topic has no children", function (t) {
-	t.plan(1);
-	t.ok(MQTTPattern.matches("foo/bar/#", "foo/bar"), "Matched childless topic");
-});
-
-test("matches() doesn't support # wildcards with more after them", function (t) {
-	t.plan(1);
-	t.notOk(MQTTPattern.matches("#/bar/baz", "foo/bar/baz"), "Didn't match topic");
-});
-
-test("matches() supports patterns with + at the beginning", function (t) {
-	t.plan(1);
-	t.ok(MQTTPattern.matches("+/bar/baz", "foo/bar/baz"), "Matched topic");
-});
-
-test("matches() supports patterns with + at the end", function (t) {
-	t.plan(1);
-	t.ok(MQTTPattern.matches("foo/bar/+", "foo/bar/baz"), "Matched topic");
-});
-
-test("matches() supports patterns with + in the middle", function (t) {
-	t.plan(1);
-	t.ok(MQTTPattern.matches("foo/+/baz", "foo/bar/baz"), "Matched topic");
-});
-
-test("matches() supports patterns multiple wildcards", function (t) {
-	t.plan(1);
-	t.ok(MQTTPattern.matches("foo/+/#", "foo/bar/baz"), "Matched topic");
-});
-
-test("matches() supports named wildcards", function (t) {
-	t.plan(1);
-	t.ok(MQTTPattern.matches("foo/+something/#else", "foo/bar/baz"), "Matched topic");
-});
-
-test("matches() supports leading slashes", function (t){
-	t.plan(2);
-	t.ok(MQTTPattern.matches("/foo/bar", "/foo/bar"), "Matched topic");
-	t.notok(MQTTPattern.matches("/foo/bar", "/bar/foo"), "Didn't match invalid topic");
-});
-
-test("extract() returns empty object of there's nothing to extract", function (t) {
-	t.plan(1);
-	t.deepEqual(MQTTPattern.extract("foo/bar/baz", "foo/bar/baz"), {}, "Extracted empty object");
-});
-
-test("extract() returns empty object if wildcards don't have label", function (t) {
-	t.plan(1);
-	t.deepEqual(MQTTPattern.extract("foo/+/#", "foo/bar/baz"), {}, "Extracted empty object");
-});
-
-test("extract() returns object with an array for # wildcard", function (t) {
-	t.plan(1);
-	t.deepEqual(MQTTPattern.extract("foo/#something", "foo/bar/baz"), {
-		something: ["bar", "baz"]
-	}, "Extracted param");
-});
-
-test("extract() returns object with a string for + wildcard", function (t) {
-	t.plan(1);
-	t.deepEqual(MQTTPattern.extract("foo/+hello/+world", "foo/bar/baz"), {
-		hello: "bar",
-		world: "baz"
-	}, "Extracted params");
-});
-
-test("extract() parses params from all wildcards", function (t) {
-	t.plan(1);
-	t.deepEqual(MQTTPattern.extract("+hello/+world/#wow", "foo/bar/baz/fizz"), {
-		hello: "foo",
-		world: "bar",
-		wow: ["baz", "fizz"]
-	}, "Extracted params");
-});
-
-test("exec() returns null if it doesn't match", function (t) {
-	t.plan(1);
-	t.equal(MQTTPattern.exec("hello/world", "foo/bar/baz"), null, "Got null");
-});
-
-test("exec() returns params if they can be parsed", function(t){
-	t.plan(1);
-	t.deepEqual(MQTTPattern.exec("foo/+hello/#world", "foo/bar/baz"), {
-		hello: "bar",
-		world: ["baz"]
-	}, "Extracted params");
-});
-
-test("fill() fills in pattern with both types of wildcards", function(t){
-	t.plan(1);
-	t.deepEqual(MQTTPattern.fill("foo/+hello/#world", {
-		hello: "Hello",
-		world: ["the", "world", "wow"],
-	}), "foo/Hello/the/world/wow", "Filled in params");
-});
-
-test("fill() fills missing + params with undefined", function(t){
-	t.plan(1);
-	t.deepEqual(
-		MQTTPattern.fill("foo/+hello", {}),
-		"foo/undefined",
-		"Filled in params"
-	);
-});
-
-test("fill() ignores empty # params", function(t){
-	t.plan(1);
-	t.deepEqual(
-		MQTTPattern.fill("foo/#hello", {}),
-		"foo",
-		"Filled in params"
-	);
-});
-
-test("fill() ignores non-named # params", function (t) {
-	t.plan(1);
-	t.deepEqual(
-		MQTTPattern.fill("foo/#", {}),
-		"foo",
-		"Filled in params"
-	);
-});
-
-test("fill() uses `undefined` for non-named + params", function(t){
-	t.plan(1);
-	t.deepEqual(
-		MQTTPattern.fill("foo/+", {}),
-		"foo/undefined",
-		"Filled in params"
-	);
-});
+"use strict";
+
+var test = require("tape");
+
+var MQTTPattern = require("./");
+
+test("matches() supports patterns with no wildcards", function (t) {
+	t.plan(1);
+	t.ok(MQTTPattern.matches("foo/bar/baz", "foo/bar/baz"), "Matched topic");
+});
+
+test("matches() doesn't match different topics", function (t) {
+	t.plan(1);
+	t.notOk(MQTTPattern.matches("foo/bar/baz", "baz/bar/foo"), "Didn't match topic");
+});
+
+test("matches() supports patterns with # at the beginning", function (t) {
+	t.plan(1);
+	t.ok(MQTTPattern.matches("#", "foo/bar/baz"), "Matched topic");
+});
+
+test("matches() supports patterns with # at the end", function (t) {
+	t.plan(1);
+	t.ok(MQTTPattern.matches("foo/#", "foo/bar/baz"), "Matched topic");
+});
+
+test("matches() supports patterns with # at the end and topic has no children", function (t) {
+	t.plan(1);
+	t.ok(MQTTPattern.matches("foo/bar/#", "foo/bar"), "Matched childless topic");
+});
+
+test("matches() doesn't support # wildcards with more after them", function (t) {
+	t.plan(1);
+	t.notOk(MQTTPattern.matches("#/bar/baz", "foo/bar/baz"), "Didn't match topic");
+});
+
+test("matches() supports patterns with + at the beginning", function (t) {
+	t.plan(1);
+	t.ok(MQTTPattern.matches("+/bar/baz", "foo/bar/baz"), "Matched topic");
+});
+
+test("matches() supports patterns with + at the end", function (t) {
+	t.plan(1);
+	t.ok(MQTTPattern.matches("foo/bar/+", "foo/bar/baz"), "Matched topic");
+});
+
+test("matches() supports patterns with + in the middle", function (t) {
+	t.plan(1);
+	t.ok(MQTTPattern.matches("foo/+/baz", "foo/bar/baz"), "Matched topic");
+});
+
+test("matches() supports patterns multiple wildcards", function (t) {
+	t.plan(1);
+	t.ok(MQTTPattern.matches("foo/+/#", "foo/bar/baz"), "Matched topic");
+});
+
+test("matches() supports named wildcards", function (t) {
+	t.plan(1);
+	t.ok(MQTTPattern.matches("foo/+something/#else", "foo/bar/baz"), "Matched topic");
+});
+
+test("matches() supports leading slashes", function (t){
+	t.plan(2);
+	t.ok(MQTTPattern.matches("/foo/bar", "/foo/bar"), "Matched topic");
+	t.notok(MQTTPattern.matches("/foo/bar", "/bar/foo"), "Didn't match invalid topic");
+});
+
+test("extract() returns empty object of there's nothing to extract", function (t) {
+	t.plan(1);
+	t.deepEqual(MQTTPattern.extract("foo/bar/baz", "foo/bar/baz"), {}, "Extracted empty object");
+});
+
+test("extract() returns empty object if wildcards don't have label", function (t) {
+	t.plan(1);
+	t.deepEqual(MQTTPattern.extract("foo/+/#", "foo/bar/baz"), {}, "Extracted empty object");
+});
+
+test("extract() returns object with an array for # wildcard", function (t) {
+	t.plan(1);
+	t.deepEqual(MQTTPattern.extract("foo/#something", "foo/bar/baz"), {
+		something: ["bar", "baz"]
+	}, "Extracted param");
+});
+
+test("extract() returns object with a string for + wildcard", function (t) {
+	t.plan(1);
+	t.deepEqual(MQTTPattern.extract("foo/+hello/+world", "foo/bar/baz"), {
+		hello: "bar",
+		world: "baz"
+	}, "Extracted params");
+});
+
+test("extract() parses params from all wildcards", function (t) {
+	t.plan(1);
+	t.deepEqual(MQTTPattern.extract("+hello/+world/#wow", "foo/bar/baz/fizz"), {
+		hello: "foo",
+		world: "bar",
+		wow: ["baz", "fizz"]
+	}, "Extracted params");
+});
+
+test("exec() returns null if it doesn't match", function (t) {
+	t.plan(1);
+	t.equal(MQTTPattern.exec("hello/world", "foo/bar/baz"), null, "Got null");
+});
+
+test("exec() returns params if they can be parsed", function(t){
+	t.plan(1);
+	t.deepEqual(MQTTPattern.exec("foo/+hello/#world", "foo/bar/baz"), {
+		hello: "bar",
+		world: ["baz"]
+	}, "Extracted params");
+});
+
+test("fill() fills in pattern with both types of wildcards", function(t){
+	t.plan(1);
+	t.deepEqual(MQTTPattern.fill("foo/+hello/#world", {
+		hello: "Hello",
+		world: ["the", "world", "wow"],
+	}), "foo/Hello/the/world/wow", "Filled in params");
+});
+
+test("fill() fills missing + params with undefined", function(t){
+	t.plan(1);
+	t.deepEqual(
+		MQTTPattern.fill("foo/+hello", {}),
+		"foo/undefined",
+		"Filled in params"
+	);
+});
+
+test("fill() ignores empty # params", function(t){
+	t.plan(1);
+	t.deepEqual(
+		MQTTPattern.fill("foo/#hello", {}),
+		"foo",
+		"Filled in params"
+	);
+});
+
+test("fill() ignores non-named # params", function (t) {
+	t.plan(1);
+	t.deepEqual(
+		MQTTPattern.fill("foo/#", {}),
+		"foo",
+		"Filled in params"
+	);
+});
+
+test("fill() uses `undefined` for non-named + params", function(t){
+	t.plan(1);
+	t.deepEqual(
+		MQTTPattern.fill("foo/+", {}),
+		"foo/undefined",
+		"Filled in params"
+	);
+});
+
+test("clean() removes parameter names", function(t){
+	t.plan(1);
+	t.equal(MQTTPattern.clean("hello/+param1/world/#param2"), "hello/+/world/#", "Got hello/+/world/#");
+});
+
+test("clean() works when there aren't any parameter names", function(t){
+	t.plan(1);
+	t.equal(MQTTPattern.clean("hello/+/world/#"), "hello/+/world/#", "Got hello/+/world/#");
+});

package/test.ts

@@ -0,0 +1,35 @@
+import { clean, exec, extract, fill, matches } from "./index";
+import { Test } from "ts-toolbelt";
+import test from "node:test";
+// Type Testing
+
+const { check, checks } = Test;
+
+// Exec
+const execv = exec("foo/bar/+baz", "foo/bar/test");
+checks([
+  check<typeof execv, { baz: string } | null, Test.Pass>(),
+  check<typeof execv, { baz: string[] } | null, Test.Fail>(),
+]);
+
+// Matches
+const matchv = matches("foo/bar/+baz", "foo/bar/test");
+check<typeof matchv, boolean, Test.Pass>();
+
+// Fill
+const fillv = fill("foo/bar/+baz/#test", {
+  baz: "test",
+  test: ["v1", "v2"],
+});
+check<typeof fillv, "foo/bar/test/v1/v2", Test.Pass>();
+
+// Extract
+const extractv = extract("foo/bar/+baz", "foo/bar/test");
+checks([
+  check<typeof extractv, { baz: string }, Test.Pass>(),
+  check<typeof extractv, { baz: string[] }, Test.Fail>(),
+]);
+
+// Clean
+const cleanv = clean("foo/bar/+baz");
+check<typeof cleanv, "foo/bar/+", Test.Pass>();