@lipemat/js-boilerplate-shared 0.0.4 → 0.1.0

package/README.md

@@ -1 +1,6 @@
 "# js-boilerplate-shared" 
+
+
+## Scripts
+
+* `js-boilerplate-shared__fix-pnp`: Fixes PNP compatibility issues

package/bin/fix-pnp.ts

@@ -0,0 +1,50 @@
+#!/usr/bin/env node
+
+/**
+ * When using PNP loose mode, we get warnings for every module
+ * we access, not strictly declared.
+ *
+ * No built-in way in Yarn to disable the warnings.
+ * This script modifies to generate .pnp.js file to suppress
+ * all loose module warnings unless the environmental variable
+ * it set to display all warnings.
+ *
+ * @example
+ * ```json
+ * {
+ *      "scripts": {
+ *           "postinstall": "lipemat-js-boilerplate fix-pnp"
+ *      }
+ *  }
+ * ```
+ */
+
+import fs from 'fs';
+
+const PNP_FILES = [
+	'./.pnp.js',
+	'./.pnp.cjs',
+	'./.pnp.mjs',
+];
+
+PNP_FILES.forEach( PNP_FILE => {
+	if ( fs.existsSync( PNP_FILE ) ) {
+		fs.readFile( PNP_FILE, 'utf8', ( readError, data ) => {
+			if ( readError ) {
+				return console.error( readError );
+			}
+
+			const result = data.replace( /if \(reference != null\) {/, '// # Warnings suppressed via @lipemat/js-boilerplate/fix-pnp script. \n' +
+				'if (! alwaysWarnOnFallback && reference != null) { \n' +
+				'dependencyReference = reference; \n' +
+				'} else if (alwaysWarnOnFallback && reference != null) {' );
+
+			fs.writeFile( PNP_FILE, result, 'utf8', writeError => {
+				if ( writeError ) {
+					return console.error( writeError );
+				}
+				console.debug( `The ${PNP_FILE} file has been adjusted to no longer display warnings for loose modules.` );
+			} );
+		} );
+	}
+} );

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lipemat/js-boilerplate-shared",
-  "version": "0.0.4",
+  "version": "0.1.0",
   "license": "MIT",
   "description": "Shared utilities for all @lipemat boilerplate packages",
   "engines": {
@@ -21,6 +21,9 @@
     "url": "https://github.com/lipemat/js-boilerplate-shared/issues"
   },
   "homepage": "https://github.com/lipemat/js-boilerplate-shared#readme",
+  "bin": {
+    "js-boilerplate-shared__fix-pnp": "bin/fix-pnp.ts"
+  },
   "scripts": {
     "build": "tsc --project ./bin",
     "lint": "eslint --fix --cache",

package/types/utility.d.ts

@@ -4,3 +4,91 @@
  * @example AtLeast<Post, 'author' | 'post_title'> - post_title and author will be required, the rest optional.
  */
 export type AtLeast<T, K extends keyof T> = Partial<T> & Required<Pick<T, K>>;
+
+/**
+ * Same as `keyof` except only keys whose value of a specified
+ * type will be returned.
+ *
+ * @example ```ts
+ *          type Post = {id: number, title: string, url: string}
+ *          KeysOfType<Post, string> - 'id' will not be included because is not string = 'title'|'url'
+ *          ```
+ */
+export type KeysOfType<T, K> = { [I in keyof T]: T[I] extends K ? I : never }[keyof T]
+
+/**
+ * Removes all the properties of type never, even the deeply nested ones.
+ *
+ * Used to provider different types based on context by assigning
+ * some properties to never.
+ *
+ * @notice Will not work properly of sub items are an `interface` they
+ *         must be a `type`.
+ *
+ * @example OmitNever<{foo: number; bar: never}> - {foo: number}
+ */
+export type OmitNever<T, Converted = {
+	[K in keyof T]:
+	// If the type of this property (excluding | undefined) is never set it to never.
+	Exclude<T[ K ], undefined> extends never ? never :
+		// If the type of this property is an object, send it through again.
+		// eslint-disable-next-line @typescript-eslint/no-restricted-types
+		T[ K ] extends Record<string, unknown> ? OmitNever<T[ K ]> : T[ K ];
+}> = Pick<Converted, {
+	// List all properties which were not set to never above.
+	[K in keyof Converted]: Converted[ K ] extends never ? never : K;
+}[ keyof Converted ]>;
+
+/**
+ * Make specified properties on a type optional.
+ *
+ * @example `Optional<Post, 'post_title'|'author'>` - `post_title` and `author` will be optional.
+ */
+export type Optional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+
+/**
+ * Make specified properties on a type required.
+ * Leave the rest of the properties as is.
+ *
+ * @example Require<UserUpdate, 'id'> - `id` will be required, the rest left as is.
+ */
+export type Require<T, K extends keyof T> = T & Required<Pick<T, K>>;
+
+/**
+ * Subtract one types properties from another.
+ *
+ * @example Subtract<Post, {id: number, post_title: string}> - id and post_title
+ * will be removed from the Post definition.
+ */
+export type Subtract<T extends K, K> = Omit<T, keyof K>;
+
+/**
+ * Exclude all top-level properties in an object that are of a type.
+ *
+ * @example ExcludeOfType<{y:'false':x:false}, boolean> = {y:'false'}
+ */
+export type ExcludeOfType<T, Type> = Pick<T, {
+	[P in keyof T]: T[P] extends Type ? never : P
+}[keyof T]>
+
+/**
+ * Union from array elements.
+ *
+ * Useful for passing to `Pick`.
+ *
+ * @example UnionOfArray<['one', 2, 'three']> - `'one' | 2 | 'three'`.
+ */
+// eslint-disable-next-line @typescript-eslint/no-restricted-types
+export type UnionOfArray<A extends Readonly<unknown[]>> = A[number];
+
+/**
+ * Combine two types, making all properties optional which
+ * do not intersect.
+ *
+ * @example OptionalNonIntersect<{foo: string, bar: number}, {foo: string, waz: boolean}> - `{foo: string, bar?: number, waz?: boolean}`.
+ */
+export type OptionalNonIntersect<T, U> =
+	Pick<T, Extract<keyof T, keyof U>> &
+	{
+		[P in Exclude<keyof T | keyof U, Extract<keyof T, keyof U>>]?: P extends keyof T ? T[P] : P extends keyof U ? U[P] : never;
+	};