fix: address review feedback from Planeshifter

- Revert lib/index.js to simple passthrough pattern
- Create separate lib/enum.js and lib/str2enum.js modules
- Update lib/native.js to use str2enum with proper spacing conventions
- Fix test/test.native.js with tryRequire pattern and stdlib spacing
- All tests passing (213/213 native, 2013/2013 standard)

Follows pattern established in heavisidef as requested by @Planeshifter

Author: rautelaKamal

lib/node_modules/@stdlib/math/base/special/heaviside/lib/enum.js

@@ -0,0 +1,52 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*    http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+// MAIN //
+
+/**
+* Returns an object mapping supported function continuity type strings to enumeration constants.
+*
+* @private
+* @returns {Object} object mapping supported function continuity types to enumeration constants
+*
+* @example
+* var table = enumeration();
+* // returns <Object>
+*/
+function enumeration() {
+    return {
+        // Half-maximum:
+        'half-maximum': 0,
+
+        // Left-continuous:
+        'left-continuous': 1,
+
+        // Right-continuous:
+        'right-continuous': 2,
+
+        // Discontinuous:
+        'discontinuous': 3
+    };
+}
+
+
+// EXPORTS //
+
+module.exports = enumeration;

lib/node_modules/@stdlib/math/base/special/heaviside/lib/index.js

@@ -50,52 +50,9 @@
 
 // MODULES //
 
-var setReadOnly = require( '@stdlib/utils/define-read-only-property' );
-var main = require( './main.js' );
-var native = require( './native.js' );
-
-
-// MAIN //
-
-/**
-* Evaluate the Heaviside function.
-*
-* @module @stdlib/math/base/special/heaviside
-*
-* @example
-* var heaviside = require( '@stdlib/math/base/special/heaviside' );
-*
-* var v = heaviside( 3.14 );
-* // returns 1.0
-*
-* v = heaviside( -3.14 );
-* // returns 0.0
-*
-* v = heaviside( 0.0 );
-* // returns NaN
-*
-* v = heaviside( 0.0, 'half-maximum' );
-* // returns 0.5
-*
-* v = heaviside( 0.0, 'left-continuous' );
-* // returns 0.0
-*
-* v = heaviside( 0.0, 'right-continuous' );
-* // returns 1.0
-*
-* v = heaviside( NaN );
-* // returns NaN
-*/
-var heaviside;
-if (native) {
-	heaviside = native;
-} else {
-	heaviside = main;
-}
-
-setReadOnly(heaviside, 'native', native);
+var main = require('./main.js');
 
 
 // EXPORTS //
 
-module.exports = heaviside;
+module.exports = main;

lib/node_modules/@stdlib/math/base/special/heaviside/lib/native.js

@@ -20,38 +20,50 @@
 
 // MODULES //
 
-var addon = require( './../src/addon.node' );
-
-
-// VARIABLES //
-
-var CONTINUITY = {
-	'half-maximum': 0,
-	'left-continuous': 1,
-	'right-continuous': 2
-};
+var addon = require('./../src/addon.node');
+var str2enum = require('./str2enum.js');
 
 
 // MAIN //
 
 /**
-* Evaluates the Heaviside function using native code.
+* Evaluates the Heaviside function.
 *
 * @private
 * @param {number} x - input value
 * @param {string} [continuity] - continuity option
 * @returns {number} function value
 *
 * @example
-* var v = heaviside( 3.14, 'half-maximum' );
+* var v = heaviside( 3.14 );
+* // returns 1.0
+*
+* @example
+* var v = heaviside( -3.14 );
+* // returns 0.0
+*
+* @example
+* var v = heaviside( 0.0, 'half-maximum' );
+* // returns 0.5
+*
+* @example
+* var v = heaviside( 0.0, 'left-continuous' );
+* // returns 0.0
+*
+* @example
+* var v = heaviside( 0.0, 'right-continuous' );
 * // returns 1.0
+*
+* @example
+* var v = heaviside( 0.0, 'discontinuous' );
+* // returns NaN
+*
+* @example
+* var v = heaviside( NaN, 'right-continuous' );
+* // returns NaN
 */
 function heaviside(x, continuity) {
-	var c = CONTINUITY[continuity];
-	if (c === void 0) {
-		c = 3; // Discontinuous
-	}
-	return addon(x, c);
+	return addon(x, str2enum(continuity));
 }
 
 

lib/node_modules/@stdlib/math/base/special/heaviside/lib/str2enum.js

@@ -0,0 +1,52 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*    http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+// MODULES //
+
+var enumeration = require('./enum.js');
+
+
+// VARIABLES //
+
+var ENUM = enumeration();
+
+
+// MAIN //
+
+/**
+* Returns the enumeration constant associated with a function continuity type string.
+*
+* @private
+* @param {string} ctype - function continuity type string
+* @returns {(integer|null)} integer value or null
+*
+* @example
+* var v = str2enum( 'left-continuous' );
+* // returns <number>
+*/
+function str2enum(ctype) {
+    var v = ENUM[ctype];
+    return (typeof v === 'number') ? v : -1; // note: we include this guard to prevent walking the prototype chain
+}
+
+
+// EXPORTS //
+
+module.exports = str2enum;

lib/node_modules/@stdlib/math/base/special/heaviside/test/test.native.js

@@ -20,51 +20,84 @@
 
 // MODULES //
 
-var tape = require( 'tape' );
-var isnan = require( '@stdlib/math/base/assert/is-nan' );
-var isPositiveZero = require( '@stdlib/math/base/assert/is-positive-zero' );
-var PINF = require( '@stdlib/constants/float64/pinf' );
-var NINF = require( '@stdlib/constants/float64/ninf' );
-var EPS = require( '@stdlib/constants/float64/eps' );
-var randu = require( '@stdlib/random/base/randu' );
-var heaviside = require( './../lib/native.js' );
+var resolve = require('path').resolve;
+var tape = require('tape');
+var isnan = require('@stdlib/math/base/assert/is-nan');
+var isPositiveZero = require('@stdlib/math/base/assert/is-positive-zero');
+var PINF = require('@stdlib/constants/float64/pinf');
+var NINF = require('@stdlib/constants/float64/ninf');
+var EPS = require('@stdlib/constants/float64/eps');
+var randu = require('@stdlib/random/base/randu');
+var tryRequire = require('@stdlib/utils/try-require');
+
+
+// VARIABLES //
+
+var heaviside = tryRequire(resolve(__dirname, './../lib/native.js'));
+var opts = {
+	'skip': (heaviside instanceof Error)
+};
 
 
 // TESTS //
 
-tape('main export is a function', function test(t) {
+tape('main export is a function', opts, function test(t) {
 	t.ok(true, __filename);
 	t.strictEqual(typeof heaviside, 'function', 'main export is a function');
 	t.end();
 });
 
-tape('the function returns `0` if `x` is negative', function test(t) {
+tape('the function returns `0` if `x` is negative', opts, function test(t) {
 	var x;
 	var v;
 	var i;
 
-	for (i = 0; i < 1e2; i++) {
+	for (i = 0; i < 1e3; i++) {
 		x = -(randu() * 100.0) - EPS;
-		v = heaviside(x, 'left-continuous');
+		v = heaviside(x);
 		t.strictEqual(isPositiveZero(v), true, 'returns expected value when provided ' + x);
 	}
 	t.end();
 });
 
-tape('the function returns `1` if `x` is positive', function test(t) {
+tape('the function returns `1` if `x` is positive', opts, function test(t) {
 	var x;
 	var v;
 	var i;
 
-	for (i = 0; i < 1e2; i++) {
+	for (i = 0; i < 1e3; i++) {
 		x = (randu() * 100.0) + EPS;
-		v = heaviside(x, 'right-continuous');
+		v = heaviside(x);
 		t.strictEqual(v, 1.0, 'returns expected value when provided ' + x);
 	}
 	t.end();
 });
 
-tape('the function returns `0.5` if provided `+-0` and continuity is `half-maximum`', function test(t) {
+tape('by default, the function returns `NaN` if provided `+-0`', opts, function test(t) {
+	var v;
+
+	v = heaviside(-0.0);
+	t.strictEqual(isnan(v), true, 'returns expected value');
+
+	v = heaviside(+0.0);
+	t.strictEqual(isnan(v), true, 'returns expected value');
+
+	t.end();
+});
+
+tape('if the `continuity` option is `discontinuous`, the function returns `NaN` if provided `+-0`', opts, function test(t) {
+	var v;
+
+	v = heaviside(-0.0, 'discontinuous');
+	t.strictEqual(isnan(v), true, 'returns expected value');
+
+	v = heaviside(+0.0, 'discontinuous');
+	t.strictEqual(isnan(v), true, 'returns expected value');
+
+	t.end();
+});
+
+tape('if the `continuity` option is `half-maximum`, the function returns `0.5` if provided `+-0`', opts, function test(t) {
 	var v;
 
 	v = heaviside(-0.0, 'half-maximum');
@@ -76,7 +109,7 @@ tape('the function returns `0.5` if provided `+-0` and continuity is `half-maxim
 	t.end();
 });
 
-tape('the function returns `0.0` if provided `+-0` and continuity is `left-continuous`', function test(t) {
+tape('if the `continuity` option is `left-continuous`, the function returns `0.0` if provided `+-0`', opts, function test(t) {
 	var v;
 
 	v = heaviside(-0.0, 'left-continuous');
@@ -88,44 +121,44 @@ tape('the function returns `0.0` if provided `+-0` and continuity is `left-conti
 	t.end();
 });
 
-tape('the function returns `1.0` if provided `+-0` and continuity is `right-continuous`', function test(t) {
+tape('if the `continuity` option is `right-continuous`, the function returns `1` if provided `+-0`', opts, function test(t) {
 	var v;
 
 	v = heaviside(-0.0, 'right-continuous');
-	t.strictEqual(v, 1.0, 'returns expected value');
+	t.strictEqual(v, 1, 'returns expected value');
 
 	v = heaviside(+0.0, 'right-continuous');
-	t.strictEqual(v, 1.0, 'returns expected value');
+	t.strictEqual(v, 1, 'returns expected value');
 
 	t.end();
 });
 
-tape('by default, the function returns `NaN` if provided `+-0`', function test(t) {
+tape('if the `continuity` option is not valid, the function returns `NaN` if provided `+-0`', opts, function test(t) {
 	var v;
 
-	v = heaviside(-0.0);
+	v = heaviside(-0.0, 'foo');
 	t.strictEqual(isnan(v), true, 'returns expected value');
 
-	v = heaviside(+0.0);
+	v = heaviside(+0.0, 'bar');
 	t.strictEqual(isnan(v), true, 'returns expected value');
 
 	t.end();
 });
 
-tape('the function returns `NaN` if provided `NaN`', function test(t) {
-	var v = heaviside(NaN);
+tape('the function returns `NaN` if provided `NaN`', opts, function test(t) {
+	var v = heaviside(NaN, 'left-continuous');
 	t.strictEqual(isnan(v), true, 'returns expected value');
 	t.end();
 });
 
-tape('the function returns `0` if provided `-infinity`', function test(t) {
-	var v = heaviside(NINF);
+tape('the function returns `0` if provided `-infinity`', opts, function test(t) {
+	var v = heaviside(NINF, 'left-continuous');
 	t.strictEqual(v, 0.0, 'returns expected value');
 	t.end();
 });
 
-tape('the function returns `+1` if provided `+infinity`', function test(t) {
-	var v = heaviside(PINF);
+tape('the function returns `+1` if provided `+infinity`', opts, function test(t) {
+	var v = heaviside(PINF, 'left-continuous');
 	t.strictEqual(v, 1.0, 'returns expected value');
 	t.end();
 });