klona

What is klona?

The klona npm package is a JavaScript utility for deep cloning objects. It allows developers to create a deep copy of an object, ensuring that changes to the new object do not affect the original object. This is particularly useful when working with complex data structures or when you need to ensure data immutability.

What are klona's main functionalities?

Deep cloning of objects

This feature allows you to create a deep clone of an object, which means that nested objects are also cloned, and changes to the cloned object do not affect the original object.

{"const klona = require('klona');\nconst original = { a: 1, b: { c: 2 } };\nconst copy = klona(original);\ncopy.b.c = 3;\nconsole.log(original.b.c); // 2\nconsole.log(copy.b.c); // 3"}

Deep cloning of arrays

Similar to object cloning, klona can also deep clone arrays, including nested arrays, ensuring that modifications to the cloned array do not affect the original array.

{"const klona = require('klona');\nconst original = [1, [2, 3], [4, 5]];\nconst copy = klona(original);\ncopy[1][0] = 'changed';\nconsole.log(original[1][0]); // 2\nconsole.log(copy[1][0]); // 'changed'"}

Cloning class instances

klona is capable of cloning instances of classes, allowing you to duplicate an instance and modify the copy without affecting the original instance.

{"const klona = require('klona');\nclass Example {\n  constructor(value) {\n    this.value = value;\n  }\n}\nconst original = new Example(1);\nconst copy = klona(original);\ncopy.value = 2;\nconsole.log(original.value); // 1\nconsole.log(copy.value); // 2"}

Other packages similar to klona

lodash

Lodash is a popular utility library that includes a `cloneDeep` function for deep cloning objects. It is more feature-rich than klona but also larger in size, which might be a consideration for projects where bundle size is a concern.

deep-copy

deep-copy is another npm package that provides deep cloning functionality. It offers similar capabilities to klona but may have different performance characteristics or API nuances.

rfdc

rfdc (Really Fast Deep Clone) is a package that focuses on performance for deep cloning objects and arrays. It claims to be faster than other deep cloning methods, which might make it a preferred choice for performance-critical applications.

README

route-sort

A tiny (200B) utility to sort route patterns by specificity.

This module is available in three formats:

• ES Module: dist/rsort.mjs
• CommonJS: dist/rsort.js
• UMD: dist/rsort.min.js

Install

$ npm install --save route-sort

Usage

import rsort from 'route-sort';

// We have multiple Author-based routes
// Note: These are currently an unsorted mess
const routes = ['/authors', '/authors/*', '/authors/:username/posts', '/authors/:username'];

const output = rsort(routes);

// Now, our routes are sorted correctly!
console.log(routes);
//=> [ '/authors', '/authors/:username', '/authors/:username/posts', '/authors/*' ]

// The original input was mutated, but it's also returned
console.log(routes === output);
//=> true

API

rsort(patterns)

Returns: Array<String>

Returns the same patterns you provide, sorted by specificity.

Important: Your original array is mutated!

patterns

Type: Array<String>

A list of route pattern strings.

Route Patterns

The supported route pattern types are:

• static – /users
• named parameters – /users/:id
• nested parameters – /users/:id/books/:title
• optional parameters – /users/:id?/books/:title?
• suffixed parameters – /movies/:title.mp4, /movies/:title.(mp4|mov)
• wildcards – /users/*

Specificity

While this working definition may not apply completely across the board, route-sort is meant to sort Express-like routing patterns in a safe manner, such that a serial traversal of the sorted array will always give you the most specific match.

You may use regexparam to convert the patterns into RegExp instances, and then use those to test an incoming URL against the patterns. We'll do that in the example below:

import rsort from 'route-sort';
import toRegExp from 'regexparam';

// We have multiple Author-based routes
// Note: These are currently an unsorted mess
const routes = ['/authors', '/authors/*', '/authors/:username/posts', '/authors/:username'];

rsort(routes);
// Now, our routes are sorted correctly!
//=> [ '/authors', '/authors/:username', '/authors/:username/posts', '/authors/*' ]

// Let's make an inefficent DEMO function to:
// 1) loop thru the `routes` array
// 2) convert each pattern to a RegExp (repetitive)
// 3) test the RegExp to see if we had a match
function find(path) {
  for (let i=0; i < routes.length; i++) {
    let { pattern } = toRegExp(routes[i]);
    if (pattern.test(path)) return routes[i];
  }
  return false; // no match
}

find('/authors'); //=> "/authors"
find('/authors/lukeed'); //=> "/authors/:username"
find('/authors/foo/bar/baz'); //=> "/authors/*"
find('/authors/lukeed/posts'); //=> "/authors/:username/posts"
find('/hello/moto'); //=> false

// Sorting was important here, but otherwise our
// original `routes` list would have matched "/authors/*"
// against every path except `/hello/moto` and `/authors`.

// Cya!

Related

• regexparam – convert route patterns to RegExp instances
• route-manifest – runtime parser of the Route Manifest format
• webpack-route-manifest – generate a Route Manifest file for your webpack build

License

MIT © Luke Edwards