@servicenow/sdk-build-core 3.0.3 → 4.0.0

package/src/plugins/time.ts

@@ -0,0 +1,108 @@
+import type { TimeDuration } from '@servicenow/sdk/core'
+
+function prefixZeroIfNeeded(n: number) {
+    return n < 10 ? `0${n}` : `${n}`
+}
+
+export function formatDateToPlatformFormat(date: Date | undefined): string {
+    if (date === undefined) {
+        return '1970-01-01 00:00:00'
+    }
+    return `${date.getUTCFullYear()}-${prefixZeroIfNeeded(date.getUTCMonth() + 1)}-${prefixZeroIfNeeded(date.getUTCDate())} ${prefixZeroIfNeeded(date.getUTCHours())}:${prefixZeroIfNeeded(date.getUTCMinutes())}:${prefixZeroIfNeeded(date.getUTCSeconds())}`
+}
+
+export function parseGlideDuration(dateTimeStr: string | undefined): TimeDuration | undefined {
+    if (!dateTimeStr) {
+        return undefined
+    }
+
+    const components = parseDateTime(dateTimeStr)
+    if (!components) {
+        return undefined
+    }
+
+    // Create Date objects for both the input time and epoch
+    const inputDate = new Date(
+        components.year,
+        components.month - 1,
+        components.day,
+        components.hours,
+        components.minutes,
+        components.seconds
+    )
+    const epochDate = new Date(1970, 0, 1, 0, 0, 0)
+
+    let diffMs = inputDate.getTime() - epochDate.getTime()
+
+    const duration: TimeDuration = {}
+
+    // Calculate days
+    const days = Math.floor(diffMs / (1000 * 60 * 60 * 24))
+    if (days > 0) {
+        duration.days = days
+        diffMs -= days * 1000 * 60 * 60 * 24
+    }
+
+    // Calculate hours
+    const hours = Math.floor(diffMs / (1000 * 60 * 60))
+    if (hours > 0) {
+        duration.hours = hours
+        diffMs -= hours * 1000 * 60 * 60
+    }
+
+    // Calculate minutes
+    const minutes = Math.floor(diffMs / (1000 * 60))
+    if (minutes > 0) {
+        duration.minutes = minutes
+        diffMs -= minutes * 1000 * 60
+    }
+
+    // Calculate seconds
+    const seconds = Math.floor(diffMs / 1000)
+    if (seconds > 0) {
+        duration.seconds = seconds
+    }
+
+    return duration
+}
+
+export function parseDateTime(dateTimeStr: string | undefined) {
+    if (!dateTimeStr) {
+        return undefined
+    }
+    const regex = /^(\d{4})-(\d{2})-(\d{2}) (\d{2}):(\d{2}):(\d{2})$/
+    const match = dateTimeStr.match(regex)
+
+    if (match) {
+        const [, year, month, day, hours, minutes, seconds] = match
+
+        return {
+            year: Number(year),
+            month: Number(month),
+            day: Number(day),
+            hours: Number(hours),
+            minutes: Number(minutes),
+            seconds: Number(seconds),
+        }
+    }
+    return undefined
+}
+
+export function durationFieldToXML(duration: TimeDuration): Date {
+    const durationInMs = toMilliseconds(
+        duration['days'] !== undefined ? duration['days'] : 0,
+        duration['hours'] !== undefined ? duration['hours'] : 0,
+        duration['minutes'] !== undefined ? duration['minutes'] : 0,
+        duration['seconds'] !== undefined ? duration['seconds'] : 0
+    )
+    return new Date(durationInMs)
+}
+
+function toMilliseconds(days: number, hours: number, minutes: number, seconds: number): number {
+    const msInDay = 24 * 60 * 60 * 1000
+    const msInHour = 60 * 60 * 1000
+    const msInMinute = 60 * 1000
+    const msInSecond = 1000
+
+    return days * msInDay + hours * msInHour + minutes * msInMinute + seconds * msInSecond
+}

package/src/plugins/usage.ts

@@ -0,0 +1,26 @@
+import type { Plugin, Shape, File, ts } from '..'
+
+export class PluginUsageTracker {
+    private readonly sourcesConvertedToRecords: Set<ts.Node | Shape | File> = new Set()
+    private readonly recordCountPerPlugin: Map<Plugin, number> = new Map()
+
+    clearPluginToRecordUsage() {
+        this.sourcesConvertedToRecords.clear()
+        this.recordCountPerPlugin.clear()
+    }
+
+    addPluginToRecordUsage(plugin: Plugin, source: ts.Node | Shape | File, count: number) {
+        if (!this.sourcesConvertedToRecords.has(source)) {
+            this.sourcesConvertedToRecords.add(source)
+            const existingCount = this.recordCountPerPlugin.get(plugin) ?? 0
+            this.recordCountPerPlugin.set(plugin, existingCount + count)
+        }
+    }
+
+    getRecordCountPerPlugin() {
+        return [...this.recordCountPerPlugin.entries()].map(([plugin, count]) => ({
+            plugin: plugin.getName().replace(/Plugin$/, ''), //Report just the names 'ACL', 'Record', etc for existing metrics compatibility
+            count,
+        }))
+    }
+}

package/src/prettier/config-loader.ts

@@ -0,0 +1,130 @@
+/**
+ * Most of this is directly from prettiers config loading
+ * https://github.com/prettier/prettier/blob/main/src/config/prettier-config/loaders.js
+ */
+
+import { pathToFileURL } from 'url'
+import { JSON5, FileSystem, path } from '..'
+import type { Options } from 'prettier'
+
+/**
+ * Resolves the closest prettier config file from the given filepath.
+ * @param filepath Path to start the search from
+ * @param fs FileSystem
+ * @returns The resolved config Options or undefined if not found
+ */
+export async function resolveConfig(
+    filepath: string,
+    fs: FileSystem,
+    resolverCache: Map<string, Options | null>
+): Promise<Options | null> {
+    const stopDir = findStopDir(path.dirname(filepath), fs)
+    const cached = resolverCache.get(stopDir)
+    if (cached) {
+        return cached
+    }
+
+    const config = await findClosest(CONFIG_FILE_NAMES, path.dirname(filepath), stopDir, fs)
+
+    resolverCache.set(stopDir, config)
+
+    return config
+}
+
+// Recursively finds the closest directory that contains a .git or .hg directory, which indicates the root of the project.
+function findStopDir(currentPath: string, fs: FileSystem): string {
+    if (FileSystem.existsSync(fs, currentPath)) {
+        const dirFiles = fs.readdirSync(currentPath, { withFileTypes: true })
+        if (dirFiles.some((d) => d.isDirectory() && (d.name === '.git' || d.name === '.hg'))) {
+            // If we found a .git or .hg directory, we stop searching which indicates we are at the root of the project
+            return currentPath
+        }
+    }
+
+    const parent = path.dirname(currentPath)
+    if (parent === currentPath) {
+        return currentPath
+    }
+
+    return findStopDir(parent, fs)
+}
+
+async function loadConfig(file: string, fs: FileSystem): Promise<Options | null> {
+    const ext = path.extname(file)
+    switch (ext) {
+        case '.json5':
+        case '.prettierrc':
+            return loadJson5(file, fs)
+        case '.json':
+            return readJson(file, fs)
+        case '.js':
+        case '.mjs':
+        case '.cjs':
+            return importModuleDefault(file)
+    }
+
+    return null
+}
+
+async function findClosest(
+    fileNames: string[],
+    currentPath: string,
+    stopDir: string,
+    fs: FileSystem
+): Promise<Options | null> {
+    if (FileSystem.existsSync(fs, currentPath)) {
+        if (FileSystem.existsSync(fs, path.join(currentPath, 'package.json'))) {
+            const pkJsonConfig = await loadConfigFromPackageJson(path.join(currentPath, 'package.json'), fs)
+            if (pkJsonConfig) {
+                return pkJsonConfig
+            }
+        }
+
+        const dirFiles = fs.readdirSync(currentPath, { withFileTypes: true })
+        for (const items of dirFiles.filter((d) => d.isFile())) {
+            if (fileNames.includes(items.name)) {
+                return loadConfig(path.join(currentPath, items.name), fs)
+            }
+        }
+    }
+
+    const parent = path.dirname(currentPath)
+    if (parent === currentPath || currentPath === stopDir) {
+        return null
+    }
+
+    return findClosest(fileNames, parent, stopDir, fs)
+}
+
+const CONFIG_FILE_NAMES = [
+    '.prettierrc',
+    '.prettierrc.json',
+    '.prettierrc.json5',
+    '.prettierrc.js',
+    '.prettierrc.mjs',
+    '.prettierrc.cjs',
+    'prettier.config.js',
+    'prettier.config.mjs',
+    'prettier.config.cjs',
+]
+
+function readJson(file: string, fs: FileSystem) {
+    const content = fs.readFileSync(file, { encoding: 'utf-8' })
+    return JSON.parse(content)
+}
+
+async function importModuleDefault(file: string) {
+    const { href } = pathToFileURL(file)
+    const module = await import(href)
+    return module.default
+}
+
+async function loadConfigFromPackageJson(file: string, fs: FileSystem) {
+    const { prettier } = readJson(file, fs)
+    return prettier
+}
+
+async function loadJson5(file: string, fs: FileSystem) {
+    const content = fs.readFileSync(file, { encoding: 'utf-8' })
+    return JSON5.parse(content)
+}

package/src/telemetry/index.ts

@@ -0,0 +1,27 @@
+export interface Telemetry {
+    sendEvent(eventData: TelemetryEvent | TelemetryEvent[]): Promise<void>
+    error(event: string, error: unknown, data?: TelemetryEventData): Promise<void>
+    startTimerEvent(name: TelemetryEvent['name']): TimerMetric
+}
+
+export interface TimerMetric {
+    end(eventData?: Pick<TelemetryEvent, 'appInfo' | 'data'>): TelemetryEvent
+}
+
+export type TelemetryEventData = Record<string, unknown>
+
+export type TelemetryEvent = { name: string; appInfo?: { scopeId?: string }; data?: TelemetryEventData }
+
+/**
+ * This is a no-op telemetry implementation that does nothing.
+ */
+export class NoOpTelemetry implements Telemetry {
+    startTimerEvent(): TimerMetric {
+        return {
+            end: () => ({ name: '', data: {} }),
+        }
+    }
+    start = () => Promise.resolve()
+    sendEvent = () => Promise.resolve()
+    error = () => Promise.resolve()
+}