@ohos-ports/font-list 0.0.0-stage → 2.1.0-beta.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017 oldj
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,255 @@
-# Temporary Holding Version
+# font-list
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+A Node.js package for listing system fonts with support for both CommonJS and ES modules.
+
+[![npm version](https://badge.fury.io/js/font-list.svg)](https://badge.fury.io/js/font-list)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+## Features
+
+- 🖥️ **Cross-platform support**: Works on macOS, Windows, and Linux
+- 📦 **Dual module support**: Compatible with both CommonJS and ES modules
+- 🔍 **Two API methods**: Basic font listing and detailed font information
+- 📝 **TypeScript support**: Includes TypeScript type definitions
+- ⚡ **Async/Promise based**: Modern asynchronous API
+
+## Installation
+
+```bash
+npm install @ohos-ports/font-list
+```
+
+## Quick Start
+
+### CommonJS
+
+```js
+const { getFonts } = require('@ohos-ports/font-list')
+
+getFonts()
+  .then(fonts => {
+    console.log(fonts)
+  })
+  .catch(err => {
+    console.error(err)
+  })
+```
+
+### ES Modules
+
+```js
+import { getFonts } from '@ohos-ports/font-list'
+
+const fonts = await getFonts()
+console.log(fonts)
+```
+
+### TypeScript
+
+```ts
+import { getFonts, FontInfo } from '@ohos-ports/font-list'
+
+const fonts: string[] = await getFonts()
+const detailedFonts: FontInfo[] = await getFonts2()
+```
+
+## API Reference
+
+### `getFonts(options?)`
+
+Returns a list of font family names available on the system.
+
+**Parameters:**
+- `options` (optional): Configuration object
+  - `disableQuoting` (boolean): If `true`, font names with spaces won't be wrapped in quotes. Default: `false`
+
+**Returns:** `Promise<string[]>`
+
+**Example output:**
+```js
+[
+  '"Adobe Arabic"',
+  '"Adobe Caslon Pro"',
+  'Arial',
+  'Helvetica',
+  ...
+]
+```
+
+**Usage examples:**
+
+```js
+// Default behavior (with quotes for names containing spaces)
+const fonts = await getFonts()
+// Result: ['"Adobe Arabic"', 'Arial', ...]
+
+// Disable quoting
+const fonts = await getFonts({ disableQuoting: true })
+// Result: ['Adobe Arabic', 'Arial', ...]
+```
+
+### `getFonts2(options?)`
+
+Returns detailed font information including both family names and PostScript names.
+
+**Parameters:**
+- `options` (optional): Same as `getFonts()`
+  - `disableQuoting` (boolean): Default: `false`
+
+**Returns:** `Promise<FontInfo[]>`
+
+**FontInfo interface:**
+```ts
+interface FontInfo {
+  name: string           // Original family name
+  familyName: string     // Standardized family name
+  postScriptName: string // PostScript name
+  weight: string         // Font weight (ultralight, light, regular, medium, semibold, bold, heavy)
+  style: string          // Font style (normal, italic, oblique)
+  width: string          // Font width (condensed, normal, expanded)
+  monospace: boolean     // Whether the font is monospaced
+}
+```
+
+**Example output:**
+```js
+[
+  {
+    name: 'Adobe Arabic',
+    familyName: '"Adobe Arabic"',
+    postScriptName: 'AdobeArabic-Regular',
+    weight: 'regular',
+    style: 'normal',
+    width: 'normal',
+    monospace: false
+  },
+  {
+    name: 'Arial',
+    familyName: 'Arial',
+    postScriptName: 'ArialMT',
+    weight: 'regular',
+    style: 'normal',
+    width: 'normal',
+    monospace: false
+  },
+  {
+    name: 'Courier New',
+    familyName: '"Courier New"',
+    postScriptName: 'CourierNewPSMT',
+    weight: 'regular',
+    style: 'normal',
+    width: 'normal',
+    monospace: true
+  },
+  ...
+]
+```
+
+**Usage examples:**
+
+```js
+// Get detailed font information
+const detailedFonts = await getFonts2()
+console.log(detailedFonts[0].familyName)     // "Adobe Arabic"
+console.log(detailedFonts[0].postScriptName) // AdobeArabic-Regular
+console.log(detailedFonts[0].weight)         // regular
+console.log(detailedFonts[0].style)          // normal
+console.log(detailedFonts[0].width)          // normal
+console.log(detailedFonts[0].monospace)      // false
+
+// With disabled quoting
+const detailedFonts = await getFonts2({ disableQuoting: true })
+console.log(detailedFonts[0].familyName)     // Adobe Arabic
+
+// Filter monospace fonts
+const monospaceFonts = detailedFonts.filter(font => font.monospace)
+console.log(monospaceFonts.map(f => f.familyName))
+
+// Filter bold fonts
+const boldFonts = detailedFonts.filter(font => font.weight === 'bold')
+console.log(boldFonts.map(f => f.familyName))
+```
+
+## Platform Support
+
+| Platform | Method | Implementation |
+|----------|--------|--------------|
+| macOS | `system_profiler` | Uses system font database |
+| Windows | PowerShell/VBS | Registry and system font queries |
+| Linux | `fc-list` | Fontconfig library |
+
+## Module Formats
+
+This package supports both CommonJS and ES modules through dual package exports:
+
+```js
+// CommonJS
+const { getFonts, getFonts2 } = require('@ohos-ports/font-list')
+
+// ES Modules
+import { getFonts, getFonts2 } from '@ohos-ports/font-list'
+
+// Default export (ES Modules)
+import fontList from '@ohos-ports/font-list'
+const fonts = await fontList.getFonts()
+```
+
+## Error Handling
+
+```js
+try {
+  const fonts = await getFonts()
+  console.log(`Found ${fonts.length} fonts`)
+} catch (error) {
+  console.error('Failed to get fonts:', error.message)
+}
+```
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+### Darwin helper binary
+
+The macOS implementation includes a native Objective-C helper binary at
+`libs/darwin/fontlist`. The binary is kept in git so macOS users can clone the
+repository and run it without a local build step. It supports two modes: no
+arguments prints the simple family-name list, while `--detail` (or `-d`) prints
+a JSON array with weight/style/width/monospace metadata.
+
+If you change `libs/darwin/fontlist.m`, rebuild the helper binary on macOS
+before submitting the change:
+
+```bash
+npm run build:darwin
+```
+
+This command requires macOS and Xcode Command Line Tools. It produces a
+universal binary with `x86_64` and `arm64` slices and a default macOS
+deployment target of `11.0`. Set `MACOSX_DEPLOYMENT_TARGET` before running the
+command to override the target for a release build. Windows and Linux
+contributors do not need to run it for JavaScript, type definition,
+documentation, or platform-specific changes outside `libs/darwin`.
+
+Pull requests should include the Darwin binary diff only when the
+Objective-C source file changed.
+
+### Publishing
+
+Releases should be published from macOS. `npm publish` runs `prepublishOnly`,
+which rebuilds the Darwin helper binary before the package is packed and
+published.
+
+To inspect the package contents before publishing, run:
+
+```bash
+npm run pack:check
+```
+
+## License
+
+MIT © [oldj](https://github.com/oldj)
+
+## Repository
+
+[https://github.com/oldj/node-font-list](https://github.com/oldj/node-font-list)

package/index.d.cts

@@ -0,0 +1,25 @@
+declare namespace fontList {
+  export interface IOptions {
+    disableQuoting: boolean;
+  }
+
+  export interface IFontInfo {
+    name: string;
+    familyName: string;
+    postScriptName: string;
+    weight: string;
+    style: string;
+    width: string;
+    monospace: boolean;
+  }
+
+  export type FontList = string[];
+  export type DetailedFontList = IFontInfo[];
+}
+
+declare const fontList: {
+  getFonts(options?: fontList.IOptions): Promise<fontList.FontList>;
+  getFonts2(options?: fontList.IOptions): Promise<fontList.DetailedFontList>;
+};
+
+export = fontList;

package/index.d.mts

@@ -0,0 +1,26 @@
+interface IOptions {
+  disableQuoting: boolean;
+}
+
+export interface IFontInfo {
+  name: string;
+  familyName: string;
+  postScriptName: string;
+  weight: string;
+  style: string;
+  width: string;
+  monospace: boolean;
+}
+
+type FontList = string[];
+type DetailedFontList = IFontInfo[];
+
+export function getFonts(options?: IOptions): Promise<FontList>;
+export function getFonts2(options?: IOptions): Promise<DetailedFontList>;
+
+declare const fontList: {
+  getFonts(options?: IOptions): Promise<FontList>;
+  getFonts2(options?: IOptions): Promise<DetailedFontList>;
+};
+
+export default fontList;

package/index.d.ts

@@ -0,0 +1,31 @@
+/**
+ * @author: oldj
+ * @homepage: https://oldj.net
+ */
+
+interface IOptions {
+  disableQuoting: boolean;
+}
+
+export interface IFontInfo {
+  name: string;
+  familyName: string;
+  postScriptName: string;
+  weight: string;
+  style: string;
+  width: string;
+  monospace: boolean;
+}
+
+type FontList = string[];
+type DetailedFontList = IFontInfo[];
+
+export function getFonts(options?: IOptions): Promise<FontList>;
+export function getFonts2(options?: IOptions): Promise<DetailedFontList>;
+
+declare const fontList: {
+  getFonts(options?: IOptions): Promise<FontList>;
+  getFonts2(options?: IOptions): Promise<DetailedFontList>;
+};
+
+export default fontList;

package/index.js

@@ -0,0 +1,12 @@
+/**
+ * @author oldj
+ * @blog http://oldj.net
+ */
+
+"use strict";
+
+const { getFonts, getFonts2 } = require("./libs/core");
+
+// CommonJS exports
+exports.getFonts = getFonts;
+exports.getFonts2 = getFonts2;

package/index.mjs

@@ -0,0 +1,19 @@
+/**
+ * @author oldj
+ * @blog http://oldj.net
+ */
+
+import { createRequire } from "module";
+
+const require = createRequire(import.meta.url);
+const { getFonts: _getFonts, getFonts2: _getFonts2 } = require("./libs/core");
+
+// ES module exports
+export const getFonts = _getFonts;
+export const getFonts2 = _getFonts2;
+
+// Default export
+export default {
+  getFonts,
+  getFonts2,
+};

package/libs/core.js

@@ -0,0 +1,100 @@
+/**
+ * @author oldj
+ * @blog http://oldj.net
+ */
+
+"use strict";
+
+const standardize = require("./standardize");
+const platform = process.platform;
+
+let getFontsFunc;
+let getDetailedFontsFunc;
+
+// Initialize platform-specific font retrieval functions
+switch (platform) {
+  case "darwin":
+    const darwinModule = require("./darwin");
+    getFontsFunc = darwinModule.getFonts;
+    getDetailedFontsFunc = darwinModule.getDetailedFonts;
+    break;
+  case "win32":
+    const win32Module = require("./win32");
+    getFontsFunc = win32Module.getFonts;
+    getDetailedFontsFunc = win32Module.getDetailedFonts;
+    break;
+  case "linux":
+  case "openharmony": // HarmonyOS: reuse the linux implementation (fc-list based)
+  case "ohos":
+    const linuxModule = require("./linux");
+    getFontsFunc = linuxModule.getFonts;
+    getDetailedFontsFunc = linuxModule.getDetailedFonts;
+    break;
+  default:
+    throw new Error(`Error: font-list can not run on ${platform}.`);
+}
+
+const defaultOptions = {
+  disableQuoting: false,
+};
+
+/**
+ * Get system font list
+ * @param {Object} options - Options
+ * @returns {Promise<string[]>} Array of font names
+ */
+async function getFonts(options) {
+  options = Object.assign({}, defaultOptions, options);
+
+  let fonts = await getFontsFunc();
+  fonts = standardize(fonts, options);
+
+  fonts.sort((a, b) => {
+    return a.replace(/^['"]+/, "").toLocaleLowerCase() <
+      b.replace(/^['"]+/, "").toLocaleLowerCase()
+      ? -1
+      : 1;
+  });
+
+  return fonts;
+}
+
+/**
+ * Get detailed system font information
+ * @param {Object} options - Options
+ * @returns {Promise<Array>} Array of detailed font information
+ */
+async function getFonts2(options) {
+  options = Object.assign({}, defaultOptions, options);
+
+  let fonts = await getDetailedFontsFunc();
+  fonts = fonts.filter(
+    (font) => font.familyName && typeof font.familyName === "string"
+  );
+
+  // Standardize familyName and pass through new attributes
+  fonts = fonts.map((font) => ({
+    name: font.familyName,
+    familyName: standardize([font.familyName], options)[0],
+    postScriptName: font.postScriptName,
+    weight: font.weight || "regular",
+    style: font.style || "normal",
+    width: font.width || "normal",
+    monospace: font.monospace || false,
+  }));
+
+  // Sort by familyName
+  fonts.sort((a, b) => {
+    return a.familyName.replace(/^['"]+/, "").toLocaleLowerCase() <
+      b.familyName.replace(/^['"]+/, "").toLocaleLowerCase()
+      ? -1
+      : 1;
+  });
+
+  return fonts;
+}
+
+module.exports = {
+  getFonts,
+  getFonts2,
+};

package/libs/darwin/fontlist.m

@@ -0,0 +1,141 @@
+#import <AppKit/AppKit.h>
+#import <Foundation/Foundation.h>
+#import <string.h>
+
+static void printSimpleList(NSArray *fontFamilyNames) {
+    for (NSString *familyName in fontFamilyNames) {
+        printf("%s\n", [familyName UTF8String]);
+    }
+}
+
+static void printDetailedJSON(NSArray *fontFamilyNames, NSFontManager *fontManager) {
+    NSMutableArray *result = [NSMutableArray arrayWithCapacity:[fontFamilyNames count]];
+
+    for (NSString *familyName in fontFamilyNames) {
+        NSArray *fontMembers = [fontManager availableMembersOfFontFamily:familyName];
+        NSString *postScriptName = familyName;
+        NSString *memberStyleName = @"";
+        unsigned int memberTraitMask = 0;
+        if (fontMembers && fontMembers.count > 0) {
+            NSArray *fontInfo = [fontMembers objectAtIndex:0];
+            postScriptName = [fontInfo objectAtIndex:0];
+            if ([fontInfo count] > 1) {
+                memberStyleName = [fontInfo objectAtIndex:1];
+            }
+            if ([fontInfo count] > 3) {
+                memberTraitMask = [[fontInfo objectAtIndex:3] unsignedIntValue];
+            }
+        }
+
+        NSString *weight = @"regular";
+        NSString *style = @"normal";
+        NSString *width = @"normal";
+        BOOL monospace = NO;
+
+        NSFont *font = [NSFont fontWithName:postScriptName size:12.0];
+        if (font) {
+            NSFontDescriptor *descriptor = [font fontDescriptor];
+            NSFontSymbolicTraits traits = [descriptor symbolicTraits];
+
+            if (traits & NSFontMonoSpaceTrait) {
+                monospace = YES;
+            }
+            if (traits & NSFontItalicTrait) {
+                style = @"italic";
+            }
+            if (traits & NSFontCondensedTrait) {
+                width = @"condensed";
+            } else if (traits & NSFontExpandedTrait) {
+                width = @"expanded";
+            }
+
+            NSDictionary *traitsDict = [descriptor objectForKey:NSFontTraitsAttribute];
+            NSNumber *weightNum = traitsDict[NSFontWeightTrait];
+            if (weightNum) {
+                CGFloat w = [weightNum doubleValue];
+                if (w <= -0.6)      weight = @"ultralight";
+                else if (w <= -0.3) weight = @"light";
+                else if (w <= 0.1)  weight = @"regular";
+                else if (w <= 0.25) weight = @"medium";
+                else if (w <= 0.35) weight = @"semibold";
+                else if (w <= 0.5)  weight = @"bold";
+                else                weight = @"heavy";
+            }
+        }
+
+        NSString *fallbackName = [[NSString stringWithFormat:@"%@ %@ %@", familyName, postScriptName, memberStyleName] lowercaseString];
+        if ([weight isEqualToString:@"regular"]) {
+            if ([fallbackName containsString:@"ultralight"] || [fallbackName containsString:@"ultra light"] ||
+                [fallbackName containsString:@"thin"]) {
+                weight = @"ultralight";
+            } else if ([fallbackName containsString:@"light"]) {
+                weight = @"light";
+            } else if ([fallbackName containsString:@"medium"]) {
+                weight = @"medium";
+            } else if ([fallbackName containsString:@"semibold"] || [fallbackName containsString:@"semi bold"] ||
+                       [fallbackName containsString:@"demibold"] || [fallbackName containsString:@"demi bold"]) {
+                weight = @"semibold";
+            } else if ([fallbackName containsString:@"bold"] || (memberTraitMask & NSBoldFontMask)) {
+                weight = @"bold";
+            } else if ([fallbackName containsString:@"heavy"] || [fallbackName containsString:@"black"]) {
+                weight = @"heavy";
+            }
+        }
+        if ([style isEqualToString:@"normal"] &&
+            ([fallbackName containsString:@"italic"] || [fallbackName containsString:@"oblique"] ||
+             (memberTraitMask & NSItalicFontMask))) {
+            style = @"italic";
+        }
+        if ([width isEqualToString:@"normal"]) {
+            if ([fallbackName containsString:@"condensed"] || [fallbackName containsString:@"narrow"] ||
+                (memberTraitMask & NSCondensedFontMask) || (memberTraitMask & NSNarrowFontMask)) {
+                width = @"condensed";
+            } else if ([fallbackName containsString:@"expanded"] || [fallbackName containsString:@"extended"] ||
+                       (memberTraitMask & NSExpandedFontMask)) {
+                width = @"expanded";
+            }
+        }
+
+        [result addObject:@{
+            @"familyName": familyName,
+            @"postScriptName": postScriptName,
+            @"weight": weight,
+            @"style": style,
+            @"width": width,
+            @"monospace": @(monospace),
+        }];
+    }
+
+    NSError *error = nil;
+    NSData *data = [NSJSONSerialization dataWithJSONObject:result
+                                                   options:NSJSONWritingPrettyPrinted
+                                                     error:&error];
+    if (!data) {
+        fprintf(stderr, "fontlist: failed to serialize JSON: %s\n",
+                error ? [[error localizedDescription] UTF8String] : "unknown error");
+        return;
+    }
+    fwrite([data bytes], 1, [data length], stdout);
+    fputc('\n', stdout);
+}
+
+int main(int argc, const char * argv[]) {
+    @autoreleasepool {
+        BOOL detailed = NO;
+        for (int i = 1; i < argc; i++) {
+            if (strcmp(argv[i], "--detail") == 0 || strcmp(argv[i], "-d") == 0) {
+                detailed = YES;
+            }
+        }
+
+        NSFontManager *fontManager = [NSFontManager sharedFontManager];
+        NSArray *fontFamilyNames = [[fontManager availableFontFamilies] sortedArrayUsingSelector:@selector(compare:)];
+
+        if (detailed) {
+            printDetailedJSON(fontFamilyNames, fontManager);
+        } else {
+            printSimpleList(fontFamilyNames);
+        }
+    }
+    return 0;
+}