fix: ensure support for "generic" dtypes

---
type: pre_commit_static_analysis_report
description: Results of running static analysis checks when committing changes.
report:
  - task: lint_filenames
    status: passed
  - task: lint_editorconfig
    status: passed
  - task: lint_markdown
    status: passed
  - task: lint_package_json
    status: na
  - task: lint_repl_help
    status: passed
  - task: lint_javascript_src
    status: na
  - task: lint_javascript_cli
    status: na
  - task: lint_javascript_examples
    status: passed
  - task: lint_javascript_tests
    status: passed
  - task: lint_javascript_benchmarks
    status: passed
  - task: lint_python
    status: na
  - task: lint_r
    status: na
  - task: lint_c_src
    status: na
  - task: lint_c_examples
    status: na
  - task: lint_c_benchmarks
    status: na
  - task: lint_c_tests_fixtures
    status: na
  - task: lint_shell
    status: na
  - task: lint_typescript_declarations
    status: passed
  - task: lint_typescript_tests
    status: passed
  - task: lint_license_headers
    status: passed
---

Author: kgryte

lib/node_modules/@stdlib/ndarray/base/trues/README.md

@@ -56,7 +56,7 @@ var dt = String( getDType( arr ) );
 
 The function accepts the following arguments:
 
--   **dtype**: underlying [data type][@stdlib/ndarray/dtypes]. Must be a "boolean" [data type][@stdlib/ndarray/dtypes].
+-   **dtype**: underlying [data type][@stdlib/ndarray/dtypes]. Must be a boolean or "generic" [data type][@stdlib/ndarray/dtypes].
 -   **shape**: array shape.
 -   **order**: specifies whether an [ndarray][@stdlib/ndarray/base/ctor] is `'row-major'` (C-style) or `'column-major'` (Fortran-style).
 
@@ -86,6 +86,9 @@ var trues = require( '@stdlib/ndarray/base/trues' );
 
 var arr = trues( 'bool', [ 2, 2 ], 'row-major' );
 console.log( ndarray2array( arr ) );
+
+arr = trues( 'generic', [ 2, 2 ], 'row-major' );
+console.log( ndarray2array( arr ) );
 ```
 
 </section>

lib/node_modules/@stdlib/ndarray/base/trues/benchmark/benchmark.js

@@ -46,3 +46,21 @@ bench( format( '%s:dtype=bool', pkg ), function benchmark( b ) {
 	b.pass( 'benchmark finished' );
 	b.end();
 });
+
+bench( format( '%s:dtype=generic', pkg ), function benchmark( b ) {
+	var arr;
+	var i;
+	b.tic();
+	for ( i = 0; i < b.iterations; i++ ) {
+		arr = trues( 'generic', [ 0 ], 'row-major' );
+		if ( arr.length !== 0 ) {
+			b.fail( 'should have length 0' );
+		}
+	}
+	b.toc();
+	if ( !isndarrayLike( arr ) ) {
+		b.fail( 'should return an ndarray' );
+	}
+	b.pass( 'benchmark finished' );
+	b.end();
+});

lib/node_modules/@stdlib/ndarray/base/trues/benchmark/benchmark.size.generic.js

@@ -0,0 +1,94 @@
+/**
+* @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 bench = require( '@stdlib/bench' );
+var pow = require( '@stdlib/math/base/special/pow' );
+var isndarrayLike = require( '@stdlib/assert/is-ndarray-like' );
+var format = require( '@stdlib/string/format' );
+var pkg = require( './../package.json' ).name;
+var trues = require( './../lib' );
+
+
+// FUNCTIONS //
+
+/**
+* Creates a benchmark function.
+*
+* @private
+* @param {PositiveInteger} len - array length
+* @returns {Function} benchmark function
+*/
+function createBenchmark( len ) {
+	return benchmark;
+
+	/**
+	* Benchmark function.
+	*
+	* @private
+	* @param {Benchmark} b - benchmark instance
+	*/
+	function benchmark( b ) {
+		var arr;
+		var i;
+
+		b.tic();
+		for ( i = 0; i < b.iterations; i++ ) {
+			arr = trues( 'generic', [ len ], 'row-major' );
+			if ( arr.length !== len ) {
+				b.fail( 'unexpected length' );
+			}
+		}
+		b.toc();
+		if ( !isndarrayLike( arr ) ) {
+			b.fail( 'should return an ndarray' );
+		}
+		b.pass( 'benchmark finished' );
+		b.end();
+	}
+}
+
+
+// MAIN //
+
+/**
+* Main execution sequence.
+*
+* @private
+*/
+function main() {
+	var len;
+	var min;
+	var max;
+	var f;
+	var i;
+
+	min = 1; // 10^min
+	max = 6; // 10^max
+
+	for ( i = min; i <= max; i++ ) {
+		len = pow( 10, i );
+		f = createBenchmark( len );
+		bench( format( '%s:dtype=generic,size=%d', pkg, len ), f );
+	}
+}
+
+main();

lib/node_modules/@stdlib/ndarray/base/trues/docs/repl.txt

@@ -6,7 +6,7 @@
     Parameters
     ----------
     dtype: string|DataType
-        Underlying data type. Must be a "boolean" data type.
+        Underlying data type. Must be a boolean or "generic" data type.
 
     shape: ArrayLikeObject<integer>
         Array shape.

lib/node_modules/@stdlib/ndarray/base/trues/docs/types/index.d.ts

@@ -20,7 +20,7 @@
 
 /// <reference types="@stdlib/types"/>
 
-import { Shape, Order, boolndarray, BooleanDataType } from '@stdlib/types/ndarray';
+import { Shape, Order, boolndarray, genericndarray, BooleanDataType, GenericDataType } from '@stdlib/types/ndarray';
 
 /**
 * Creates an ndarray filled with `true` values and having a specified shape and data type.
@@ -41,6 +41,25 @@ import { Shape, Order, boolndarray, BooleanDataType } from '@stdlib/types/ndarra
 */
 declare function trues( dtype: BooleanDataType, shape: Shape, order: Order ): boolndarray;
 
+/**
+* Creates an ndarray filled with `true` values and having a specified shape and data type.
+*
+* @param dtype - underlying data type
+* @param shape - array shape
+* @param order - specifies whether an array is row-major (C-style) or column-major (Fortran-style)
+* @returns `true`-filled array
+*
+* @example
+* var getDType = require( '@stdlib/ndarray/dtype' );
+*
+* var arr = trues( 'generic', [ 2, 2 ], 'row-major' );
+* // returns <ndarray>[ [ true, true ], [ true, true ] ]
+*
+* var dt = String( getDType( arr ) );
+* // returns 'generic'
+*/
+declare function trues( dtype: GenericDataType, shape: Shape, order: Order ): genericndarray<boolean>;
+
 
 // EXPORTS //
 

lib/node_modules/@stdlib/ndarray/base/trues/docs/types/test.ts

@@ -25,6 +25,7 @@ import trues = require( './index' );
 {
 	trues( 'bool', [ 2, 2 ], 'row-major' ); // $ExpectType boolndarray
 	trues( 'bool', [ 2, 2 ], 'column-major' ); // $ExpectType boolndarray
+	trues( 'generic', [ 2, 2 ], 'column-major' ); // $ExpectType genericndarray<boolean>
 }
 
 // The compiler throws an error if the function is provided a first argument which is an unrecognized/unsupported data type...

lib/node_modules/@stdlib/ndarray/base/trues/examples/index.js

@@ -23,3 +23,6 @@ var trues = require( './../lib' );
 
 var arr = trues( 'bool', [ 2, 2 ], 'row-major' );
 console.log( ndarray2array( arr ) );
+
+arr = trues( 'generic', [ 2, 2 ], 'row-major' );
+console.log( ndarray2array( arr ) );

lib/node_modules/@stdlib/ndarray/base/trues/test/test.js

@@ -22,6 +22,7 @@
 
 var tape = require( 'tape' );
 var instanceOf = require( '@stdlib/assert/instance-of' );
+var isEqualArray = require( '@stdlib/assert/is-equal-array' );
 var isEqualBooleanArray = require( '@stdlib/assert/is-equal-booleanarray' );
 var BooleanArray = require( '@stdlib/array/bool' );
 var ndarray = require( '@stdlib/ndarray/base/ctor' );
@@ -109,6 +110,40 @@ tape( 'the function returns a `true`-filled array (dtype=bool, order=column-majo
 	t.end();
 });
 
+tape( 'the function returns a `true`-filled array (dtype=generic, order=row-major)', function test( t ) {
+	var expected;
+	var arr;
+
+	expected = [ true, true, true, true ];
+
+	arr = trues( 'generic', [ 2, 2 ], 'row-major' );
+	t.strictEqual( instanceOf( arr, ndarray ), true, 'returns expected value' );
+	t.strictEqual( String( getDType( arr ) ), 'generic', 'returns expected value' );
+	t.deepEqual( getShape( arr ), [ 2, 2 ], 'returns expected value' );
+	t.strictEqual( instanceOf( getData( arr ), Array ), true, 'returns expected value' );
+	t.strictEqual( isEqualArray( getData( arr ), expected ), true, 'returns expected value' );
+	t.strictEqual( getOrder( arr ), 'row-major', 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function returns a `true`-filled array (dtype=generic, order=column-major)', function test( t ) {
+	var expected;
+	var arr;
+
+	expected = [ true, true, true, true ];
+
+	arr = trues( 'generic', [ 2, 2 ], 'column-major' );
+	t.strictEqual( instanceOf( arr, ndarray ), true, 'returns expected value' );
+	t.strictEqual( String( getDType( arr ) ), 'generic', 'returns expected value' );
+	t.deepEqual( getShape( arr ), [ 2, 2 ], 'returns expected value' );
+	t.strictEqual( instanceOf( getData( arr ), Array ), true, 'returns expected value' );
+	t.strictEqual( isEqualArray( getData( arr ), expected ), true, 'returns expected value' );
+	t.strictEqual( getOrder( arr ), 'column-major', 'returns expected value' );
+
+	t.end();
+});
+
 tape( 'the function supports zero-dimensional arrays', function test( t ) {
 	var expected;
 	var arr;