@magic/semver 0.0.16 → 0.0.17

package/README.md

@@ -22,11 +22,13 @@ semantic version parsing and stringification
 [snyk-url]: https://snyk.io/test/github/magic/semver
 
 #### installation:
+
 ```javascript
 npm install @magic/semver
 ```
 
 #### usage:
+
 ```javascript
 import semver from '@magic/semver'
 
@@ -40,61 +42,82 @@ const parsed = semver.parse(version)
 const serialized = semver.serialize(parsed)
 
 // version === serialized
-
 ```
 
 ##### changelog
 
 ##### 0.0.1
+
 first release
 
 ##### 0.0.2
+
 add bump and isSemver
 
 ##### 0.0.3
+
 handle -alpha and -beta separately to stop decrementing the version by mistake.
 
 ##### 0.0.4
+
 fix behaviour of appending -alpha.0 and -beta.0.
 these two edgecases also bump patch version now.
 
 ##### 0.0.5
+
 add isBigger and isSmaller version comparison
 
 ##### 0.0.6
+
 remove @magic/fs
 
-##### 0.0.7 
+##### 0.0.7
+
 bump required node version to 14.2.0
 
-##### 0.0.8 
+##### 0.0.8
+
 update dependencies
 
 ##### 0.0.9
-* bump required node version to 14.15.4
-* update dependencies
+
+- bump required node version to 14.15.4
+- update dependencies
 
 ##### 0.0.10
-* update README
-* bump dev dependencies
 
-##### 0.0.11 
+- update README
+- bump dev dependencies
+
+##### 0.0.11
+
 update dependencies
 
 ##### 0.0.12
+
 update dependencies
 
 ##### 0.0.13
+
 update dependencies
 
 ##### 0.0.14
+
 update dependencies
 
 ##### 0.0.15
+
 update dependencies
 
 ##### 0.0.16
+
 update dependencies
 
-##### 0.0.17 - unreleased
+##### 0.0.17
+
+- add typescript
+- update dependencies
+
+##### 0.0.18 - unreleased
+
 ...

package/package.json

@@ -1,22 +1,29 @@
 {
   "name": "@magic/semver",
-  "version": "0.0.16",
+  "version": "0.0.17",
   "author": "Wizards & Witches",
   "description": "semantic version parsing and serialization.",
   "license": "AGPL-3.0",
   "homepage": "https://magic.github.io/semver",
-  "main": "src/index.mjs",
+  "main": "src/index.js",
+  "types": "types/index.d.ts",
+  "module": "src/index.js",
   "type": "module",
   "scripts": {
-    "start": "t -p",
+    "start": "npm test",
+    "build": "npm run build:docs",
+    "build:types": "tsc && npm run format",
+    "prepublishOnly": "npm run test && npm run build:types",
     "test": "t --exclude docs example config.js",
     "format": "f -w --exclude docs",
     "format:check": "f",
     "calls": "calls",
-    "build": "NODE_ENV=production magic build",
+    "build:docs": "NODE_ENV=production magic build",
     "prod": "NODE_ENV=production magic build serve",
     "clean": "magic clean",
-    "dev": "magic dev"
+    "serve": "magic serve",
+    "dev": "magic dev",
+    "lint": "tsc --noEmit"
   },
   "engine": {
     "node": ">=14.15.4"
@@ -30,21 +37,23 @@
     "url": "https://github.com/magic/semver/issues"
   },
   "dependencies": {
-    "@magic/error": "0.0.16",
-    "@magic/types": "0.1.22"
+    "@magic/error": "0.0.21",
+    "@magic/types": "0.1.31"
   },
   "devDependencies": {
     "@magic-modules/git-badges": "0.0.12",
-    "@magic-modules/light-switch": "0.0.11",
-    "@magic-modules/no-spy": "0.0.7",
-    "@magic-modules/pre": "0.0.11",
-    "@magic-themes/docs": "0.0.14",
-    "@magic/core": "0.0.142",
-    "@magic/format": "0.0.41",
-    "@magic/test": "0.2.12"
+    "@magic-modules/light-switch": "0.0.12",
+    "@magic-modules/no-spy": "0.0.9",
+    "@magic-modules/pre": "0.0.12",
+    "@magic-themes/docs": "0.0.15",
+    "@magic/core": "0.0.156",
+    "@magic/format": "0.0.69",
+    "@magic/test": "0.2.28",
+    "typescript": "5.9.3"
   },
   "files": [
-    "src"
+    "src",
+    "types"
   ],
   "contributors": [
     {

package/src/{bump.mjs → bump.js}

@@ -1,22 +1,39 @@
-import path from 'path'
-
 import error from '@magic/error'
 import is from '@magic/types'
 
-import { parse } from './parse.mjs'
-import { serialize } from './serialize.mjs'
-import { isSemver } from './isSemver.mjs'
+import { parse } from './parse.js'
+import { serialize } from './serialize.js'
+import { isSemver } from './isSemver.js'
 
 const libName = '@magic/semver.bump'
 
-export const bump = (version, options = {}) => {
-  if (is.empty(version)) {
+/**
+ *  @typedef {import('./types.js').Version} Version
+ */
+
+/**
+ * @param {string} v
+ * @param {object} options
+ * @param {boolean} [options.major]
+ * @param {boolean} [options.minor]
+ * @param {boolean} [options.patch]
+ * @param {boolean} [options.beta]
+ * @param {boolean} [options.alpha]
+ * @returns {Version | string}
+ */
+export const bump = (v, options = {}) => {
+  if (is.empty(v)) {
     throw error(`${libName} expects arguments to be non-empty`, 'E_VERSION_EMPTY')
   }
 
-  const isString = is.string(version)
+  /** @type {Partial<Version> } */
+  let version
+
+  const isString = is.string(v)
   if (isString) {
-    version = parse(version)
+    version = parse(v)
+  } else {
+    version = v
   }
 
   if (!isSemver(version)) {
@@ -30,16 +47,16 @@ export const bump = (version, options = {}) => {
     version.major += 1
     version.minor = 0
     version.patch = 0
-    version.demo = {}
+    version.demo = undefined
   } else if (options.minor) {
     version.minor += 1
     version.patch = 0
-    version.demo = {}
+    version.demo = undefined
   } else if (options.patch) {
     version.patch += 1
-    version.demo = {}
+    version.demo = undefined
   } else if (options.beta) {
-    if (is.empty(version.demo)) {
+    if (!version.demo) {
       version.patch += 1
       version.demo = {
         string: 'beta',
@@ -54,32 +71,35 @@ export const bump = (version, options = {}) => {
       version.demo.version += 1
     }
   } else if (options.alpha) {
-    if (is.empty(version.demo)) {
-      version.patch += 1
+    if (version.demo?.string === 'beta') {
+      throw error(
+        `${libName} got request to set ${JSON.stringify({ version })} to alpha. can not decrement versions.`,
+        'E_NO_DECREMENT',
+      )
+    }
 
+    if (!version.demo) {
+      version.patch += 1
       version.demo = {
         string: 'alpha',
         version: 0,
       }
-    } else {
-      if (version.demo.string !== 'alpha') {
-        throw error(
-          `${libName} got request to set ${version.demo.string} to alpha. can not decrement versions.`,
-          'E_NO_DECREMENT',
-        )
-      }
-
+    } else if (version.demo.string === 'alpha') {
       version.demo.version += 1
     }
   } else {
     // no arguments given. bump alpha version if given, patch if not
-    if (!is.empty(version.demo)) {
+    if (!is.undefined(version.demo)) {
       version.demo.version += 1
     } else {
       version.patch += 1
     }
   }
 
+  if (is.empty(version.demo)) {
+    delete version.demo
+  }
+
   if (isString) {
     return serialize(version)
   }

package/src/{index.mjs → index.js}

@@ -1,8 +1,8 @@
-import { bump as b } from './bump.mjs'
-import { isBigger as isB, isSmaller as isS } from './length.mjs'
-import { isSemver as is } from './isSemver.mjs'
-import { parse as p } from './parse.mjs'
-import { serialize as s } from './serialize.mjs'
+import { bump as b } from './bump.js'
+import { isBigger as isB, isSmaller as isS } from './length.js'
+import { isSemver as is } from './isSemver.js'
+import { parse as p } from './parse.js'
+import { serialize as s } from './serialize.js'
 
 export const bump = b
 export const isBigger = isB

package/src/isSemver.js

@@ -0,0 +1,28 @@
+import is from '@magic/types'
+import { parse } from './parse.js'
+import { serialize } from './serialize.js'
+
+/**
+ * @typedef {import('./types.js').Version} Version
+ */
+
+/**
+ * @param {Version | string | unknown} v
+ * @returns {v is Version}
+ *
+ */
+export const isSemver = v => {
+  try {
+    if (is.string(v)) {
+      const p = parse(v)
+
+      return is.obj(p) && is.num(p.major) && is.num(p.minor) && is.num(p.patch)
+    } else {
+      const s = serialize(v)
+
+      return is.str(s) && is.num(parseInt(s.split('.')[1]))
+    }
+  } catch {}
+
+  return false
+}

package/src/{length.mjs → length.js}

@@ -1,6 +1,14 @@
 import is from '@magic/types'
 
-import { parse } from './parse.mjs'
+import { parse } from './parse.js'
+import { isSemver } from './isSemver.js'
+
+/**
+ *
+ * @param {string} a
+ * @param {string} b
+ * @returns {boolean}
+ */
 
 export const isBigger = (a, b) => {
   if (a === b) {
@@ -10,6 +18,10 @@ export const isBigger = (a, b) => {
   const pA = parse(a)
   const pB = parse(b)
 
+  if (!isSemver(a) || !isSemver(b)) {
+    return false
+  }
+
   if (pA.major > pB.major) {
     return true
   }
@@ -35,18 +47,30 @@ export const isBigger = (a, b) => {
       return false
     }
 
-    if (pA.demo.string === 'beta' && pB.demo.string === 'alpha') {
-      return true
-    }
-
-    if (pA.demo.string === pB.demo.string) {
-      if (pA.demo.version > pB.demo.version) {
+    if (pA.demo && pB.demo) {
+      if (pA.demo.string === 'beta' && pB.demo.string === 'alpha') {
         return true
       }
+
+      if (pA.demo.string === pB.demo.string) {
+        if (pA.demo.version > pB.demo.version) {
+          return true
+        }
+      }
+    } else if (!pA.demo && pB.demo) {
+      return true
+    } else if (pA.demo && !pB.demo) {
+      return false
     }
   }
 
   return false
 }
 
+/**
+ *
+ * @param {string} a
+ * @param {string} b
+ * @returns
+ */
 export const isSmaller = (a, b) => !isBigger(a, b)

package/src/{parse.mjs → parse.js}

@@ -3,6 +3,15 @@ import error from '@magic/error'
 
 const libName = `@magic/semver.parse:`
 
+/**
+ * @typedef {import('./types.js').Version} Version
+ * @typedef {import('./types.js').VersionResult} VersionResult
+ */
+
+/**
+ * @param {string} v
+ * @returns {VersionResult}
+ */
 export const parse = v => {
   if (is.empty(v)) {
     throw error(`${libName} first argument must be non-empty`, 'E_ARG_EMPTY')
@@ -18,10 +27,12 @@ export const parse = v => {
 
   const [major, minor, patch, demo] = v.split('.')
 
+  /** @type {VersionResult} */
   const result = {
     major: parseInt(major),
     minor: parseInt(minor),
-    demo: {},
+    patch: -1,
+    v,
   }
 
   if (is.string(patch) && patch.includes('-')) {
@@ -42,11 +53,9 @@ export const parse = v => {
     throw error(`${libName} minor was not an Int: ${result.minor}`, 'E_MINOR_TYPE')
   } else if (!is.number(result.patch)) {
     throw error(`${libName} patch was not an Int: ${result.patch}`, 'E_PATCH_TYPE')
-  } else if (!is.empty(result.demo) && !is.number(result.demo.version)) {
-    throw error(`${libName} demo was not an Int: ${result.demo.version}`, 'E_DEMO_TYPE')
+  } else if (!is.empty(result.demo) && !is.number(result.demo?.version)) {
+    throw error(`${libName} demo was not an Int: ${result.demo?.version}`, 'E_DEMO_TYPE')
   }
 
-  result.v = v
-
   return result
 }

package/src/{serialize.mjs → serialize.js}

@@ -3,29 +3,37 @@ import error from '@magic/error'
 
 const libName = `@magic/semver.serialize:`
 
+/**
+ *  @typedef {import('./types.js').Version} Version
+ */
+
+/**
+ * @param {Version | unknown} v
+ * @returns {string}
+ */
 export const serialize = v => {
   if (is.empty(v)) {
     throw error(`${libName} v must be non-empty`, 'E_ARG_EMPTY')
   }
 
   // the || v.major is a cheap test to make sure we get a valid object
-  if (!is.object(v) || !v.hasOwnProperty('major')) {
+  if (!is.objectNative(v) || !v.hasOwnProperty('major')) {
     throw error(`${libName} v must be an object`, 'E_ARG_TYPE')
   }
 
-  const major = parseInt(v.major)
+  const major = v.major
 
   if (!is.number(major)) {
     throw error(`${libName} major was not an Int: ${major}`, 'E_MAJOR_TYPE')
   }
 
-  const minor = parseInt(v.minor)
+  const minor = v.minor
 
   if (!is.number(minor)) {
     throw error(`${libName} minor was not an Int: ${minor}`, 'E_MINOR_TYPE')
   }
 
-  const patch = parseInt(v.patch)
+  const patch = v.patch
 
   if (!is.number(patch)) {
     throw error(`${libName} patch was not an Int: ${patch}`, 'E_PATCH_TYPE')
@@ -33,9 +41,12 @@ export const serialize = v => {
 
   let demoString = ''
 
-  if (!is.empty(v.demo)) {
+  if (!is.empty(v.demo) && is.objectNative(v.demo)) {
     let { version, string } = v.demo
-    version = parseInt(version)
+
+    if (is.str(version)) {
+      version = parseInt(version)
+    }
 
     if (!is.number(version)) {
       throw error(`${libName} demo was not an Int: ${version}`, 'E_DEMO_TYPE')

package/src/types.ts

@@ -0,0 +1,11 @@
+export type Version = {
+  major: number
+  minor: number
+  patch: number
+  demo?: {
+    string: string
+    version: number
+  }
+}
+
+export type VersionResult = Version & { v: string }

package/types/bump.d.mts

@@ -0,0 +1 @@
+export function bump(version: any, options?: {}): any

package/types/bump.d.ts

@@ -0,0 +1,11 @@
+export function bump(
+  v: string,
+  options?: {
+    major?: boolean | undefined
+    minor?: boolean | undefined
+    patch?: boolean | undefined
+    beta?: boolean | undefined
+    alpha?: boolean | undefined
+  },
+): Version | string
+export type Version = import('./types.js').Version

package/types/index.d.mts

@@ -0,0 +1,21 @@
+export const bump: (version: any, options?: {}) => any
+export const isBigger: (a: any, b: any) => boolean
+export const isSemver: (v: any) => boolean
+export const isSmaller: (a: any, b: any) => boolean
+export const parse: (v: any) => {
+  major: number
+  minor: number
+  demo: {}
+}
+export const stringify: (v: any) => string
+export const serialize: (v: any) => string
+declare namespace _default {
+  export { bump }
+  export { isBigger }
+  export { isSemver }
+  export { isSmaller }
+  export { parse }
+  export { serialize }
+  export { stringify }
+}
+export default _default

package/types/index.d.ts

@@ -0,0 +1,26 @@
+export const bump: (
+  v: string,
+  options?: {
+    major?: boolean | undefined
+    minor?: boolean | undefined
+    patch?: boolean | undefined
+    beta?: boolean | undefined
+    alpha?: boolean | undefined
+  },
+) => Version | string
+export const isBigger: (a: string, b: string) => boolean
+export const isSemver: (v: Version | string | unknown) => v is Version
+export const isSmaller: (a: string, b: string) => boolean
+export const parse: (v: string) => VersionResult
+export const stringify: (v: Version | unknown) => string
+export const serialize: (v: Version | unknown) => string
+declare namespace _default {
+  export { bump }
+  export { isBigger }
+  export { isSemver }
+  export { isSmaller }
+  export { parse }
+  export { serialize }
+  export { stringify }
+}
+export default _default

package/types/isSemver.d.mts

@@ -0,0 +1 @@
+export function isSemver(v: any): boolean

package/types/isSemver.d.ts

@@ -0,0 +1,2 @@
+export function isSemver(v: Version | string | unknown): v is Version
+export type Version = import('./types.js').Version

package/types/length.d.mts

@@ -0,0 +1,2 @@
+export function isBigger(a: any, b: any): boolean
+export function isSmaller(a: any, b: any): boolean

package/types/length.d.ts

@@ -0,0 +1,2 @@
+export function isBigger(a: string, b: string): boolean
+export function isSmaller(a: string, b: string): boolean

package/types/parse.d.mts

@@ -0,0 +1,5 @@
+export function parse(v: any): {
+  major: number
+  minor: number
+  demo: {}
+}

package/types/parse.d.ts

@@ -0,0 +1,3 @@
+export function parse(v: string): VersionResult
+export type Version = import('./types.js').Version
+export type VersionResult = import('./types.js').VersionResult

package/types/serialize.d.mts

@@ -0,0 +1 @@
+export function serialize(v: any): string

package/types/serialize.d.ts

@@ -0,0 +1,2 @@
+export function serialize(v: Version | unknown): string
+export type Version = import('./types.js').Version

package/types/types.d.ts

@@ -0,0 +1,12 @@
+export type Version = {
+  major: number
+  minor: number
+  patch: number
+  demo?: {
+    string: string
+    version: number
+  }
+}
+export type VersionResult = Version & {
+  v: string
+}

package/src/isSemver.mjs

@@ -1,19 +0,0 @@
-import is from '@magic/types'
-import { parse } from './parse.mjs'
-import { serialize } from './serialize.mjs'
-
-export const isSemver = v => {
-  try {
-    if (is.string(v)) {
-      const p = parse(v)
-
-      return is.obj(p) && is.num(p.major)
-    } else {
-      const s = serialize(v)
-
-      return is.str(s) && is.num(parseInt(s.split('.')[1]))
-    }
-  } catch (_) {
-    return false
-  }
-}