@burdenoff/fe-libs 2026.510.126

package/shared/config/eslint.config.mjs

@@ -0,0 +1,53 @@
+import js from '@eslint/js';
+import globals from 'globals';
+import reactHooks from 'eslint-plugin-react-hooks';
+import react from 'eslint-plugin-react';
+import tseslint from 'typescript-eslint';
+
+/**
+ * Creates a shared ESLint configuration for Burdenoff frontend projects.
+ * @param {Object} options - Configuration options
+ * @param {string[]} options.ignores - Additional ignore patterns
+ * @param {Record<string, unknown>} options.additionalRules - Additional ESLint rules
+ * @returns {import('eslint').Linter.FlatConfig[]} ESLint flat config array
+ */
+export function createEslintConfig(options = {}) {
+  const { ignores = [], additionalRules = {} } = options;
+
+  return tseslint.config(
+    { ignores: ['**/dist', '**/node_modules', '**/*.stories.tsx', ...ignores] },
+    {
+      extends: [js.configs.recommended, ...tseslint.configs.recommended],
+      files: ['**/*.{ts,tsx}'],
+      languageOptions: {
+        ecmaVersion: 2024,
+        globals: globals.browser,
+        parserOptions: {
+          ecmaFeatures: {
+            jsx: true,
+          },
+        },
+      },
+      plugins: {
+        react,
+        'react-hooks': reactHooks,
+      },
+      rules: {
+        ...react.configs.recommended.rules,
+        ...react.configs['jsx-runtime'].rules,
+        ...reactHooks.configs.recommended.rules,
+        'react/prop-types': 'off',
+        '@typescript-eslint/no-unused-vars': ['warn', { argsIgnorePattern: '^_' }],
+        '@typescript-eslint/no-explicit-any': 'error',
+        ...additionalRules,
+      },
+      settings: {
+        react: {
+          version: 'detect',
+        },
+      },
+    }
+  );
+}
+
+export default createEslintConfig;

package/shared/config/prettier.config.d.mts

@@ -0,0 +1,5 @@
+import type { Config } from 'prettier';
+
+declare const prettierConfig: Config;
+
+export default prettierConfig;

package/shared/config/prettier.config.mjs

@@ -0,0 +1,18 @@
+/**
+ * Shared Prettier configuration for Burdenoff frontend projects.
+ * @type {import('prettier').Config}
+ */
+const prettierConfig = {
+  semi: true,
+  singleQuote: true,
+  tabWidth: 2,
+  trailingComma: 'es5',
+  printWidth: 100,
+  bracketSpacing: true,
+  arrowParens: 'always',
+  endOfLine: 'lf',
+  jsxSingleQuote: false,
+  bracketSameLine: false,
+};
+
+export default prettierConfig;

package/shared/config/tsconfig.base.json

@@ -0,0 +1,23 @@
+{
+  "$schema": "https://json.schemastore.org/tsconfig",
+  "compilerOptions": {
+    "target": "ES2022",
+    "lib": ["ES2022", "DOM", "DOM.Iterable"],
+    "module": "ESNext",
+    "skipLibCheck": true,
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "noEmit": true,
+    "jsx": "react-jsx",
+    "strict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noFallthroughCasesInSwitch": true,
+    "forceConsistentCasingInFileNames": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true
+  }
+}

package/src/shared/shims/assert.ts

@@ -0,0 +1,54 @@
+/**
+ * Assert polyfill for browser environment.
+ * Required by adaptivecards-templating (antlr4ts dependency).
+ *
+ * Sets assert globally so bundled libraries can access it.
+ *
+ * @module @burdenoff/fe-libs/shared/shims/assert
+ */
+
+function assert(condition: unknown, message?: string): asserts condition {
+  if (!condition) {
+    throw new Error(message || "Assertion failed");
+  }
+}
+
+// Add methods for Node.js assert compatibility
+assert.ok = assert;
+assert.strictEqual = (actual: unknown, expected: unknown, message?: string) => {
+  if (actual !== expected) {
+    throw new Error(message || `Expected ${expected} but got ${actual}`);
+  }
+};
+assert.notStrictEqual = (
+  actual: unknown,
+  expected: unknown,
+  message?: string,
+) => {
+  if (actual === expected) {
+    throw new Error(message || `Expected ${actual} to not equal ${expected}`);
+  }
+};
+assert.deepStrictEqual = (
+  actual: unknown,
+  expected: unknown,
+  message?: string,
+) => {
+  if (JSON.stringify(actual) !== JSON.stringify(expected)) {
+    throw new Error(message || `Deep equality assertion failed`);
+  }
+};
+assert.fail = (message?: string) => {
+  throw new Error(message || "Assertion failed");
+};
+
+// Set as global for bundled libraries that expect it
+if (typeof window !== "undefined") {
+  (window as unknown as Record<string, unknown>).assert = assert;
+}
+if (typeof globalThis !== "undefined") {
+  (globalThis as unknown as Record<string, unknown>).assert = assert;
+}
+
+export { assert };
+export default assert;

package/src/shared/shims/index.ts

@@ -0,0 +1,27 @@
+/**
+ * Browser shims for Node.js modules.
+ *
+ * App shells should import and install these shims in their entry point
+ * (main.tsx) before any other imports:
+ *
+ * ```ts
+ * import "@burdenoff/fe-libs/shared/shims/assert";
+ * import processShim from "@burdenoff/fe-libs/shared/shims/process";
+ * ```
+ *
+ * For Vite resolve aliases, use the paths exported here:
+ *
+ * ```ts
+ * import { getShimPaths } from "@burdenoff/fe-libs/shared/shims";
+ * ```
+ *
+ * @module @burdenoff/fe-libs/shared/shims
+ */
+
+export { assert } from "./assert";
+export { default as processShim } from "./process";
+export { useSyncExternalStoreWithSelector } from "./use-sync-external-store-with-selector";
+export { useSyncExternalStore } from "./use-sync-external-store-shim";
+
+// Re-export for direct use as module aliases
+export * as utilShim from "./util";

package/src/shared/shims/process.ts

@@ -0,0 +1,24 @@
+/**
+ * Process polyfill for browser environment.
+ * Provides a minimal Node.js process shim for libraries that depend on it.
+ *
+ * @module @burdenoff/fe-libs/shared/shims/process
+ */
+
+const processShim = {
+  env: {},
+  browser: true,
+  platform: "browser",
+  cwd: () => "/",
+  nextTick: (callback: (...args: unknown[]) => void, ...args: unknown[]) => {
+    queueMicrotask(() => callback(...args));
+  },
+};
+
+export const env = processShim.env;
+export const browser = processShim.browser;
+export const platform = processShim.platform;
+export const cwd = processShim.cwd;
+export const nextTick = processShim.nextTick;
+
+export default processShim;

package/src/shared/shims/use-sync-external-store-shim.ts

@@ -0,0 +1,15 @@
+/**
+ * Re-export React 19's useSyncExternalStore.
+ * Zustand v5 and other libraries import from "use-sync-external-store/shim"
+ * which is unnecessary in React 19+ but the imports still exist in compiled code.
+ *
+ * @module @burdenoff/fe-libs/shared/shims/use-sync-external-store-shim
+ */
+
+import { useSyncExternalStore } from "react";
+
+export { useSyncExternalStore };
+
+export default {
+  useSyncExternalStore,
+};

package/src/shared/shims/use-sync-external-store-with-selector.ts

@@ -0,0 +1,112 @@
+/**
+ * Full implementation of useSyncExternalStoreWithSelector.
+ * Required for zustand compatibility in React 19 environments.
+ *
+ * This replaces the "use-sync-external-store/with-selector" package
+ * which ships as CJS and breaks ESM-only browser builds.
+ *
+ * @module @burdenoff/fe-libs/shared/shims/use-sync-external-store-with-selector
+ */
+
+import {
+  useDebugValue,
+  useEffect,
+  useMemo,
+  useRef,
+  useSyncExternalStore,
+} from "react";
+
+type Selector<TSnapshot, TSelection> = (snapshot: TSnapshot) => TSelection;
+type IsEqual<TSelection> = (a: TSelection, b: TSelection) => boolean;
+
+interface SelectorInstance<TSelection> {
+  hasValue: boolean;
+  value: TSelection | null;
+}
+
+const objectIs = Object.is;
+
+export function useSyncExternalStoreWithSelector<TSnapshot, TSelection>(
+  subscribe: (onStoreChange: () => void) => () => void,
+  getSnapshot: () => TSnapshot,
+  getServerSnapshot: (() => TSnapshot) | undefined,
+  selector: Selector<TSnapshot, TSelection>,
+  isEqual?: IsEqual<TSelection>,
+): TSelection {
+  const instRef = useRef<SelectorInstance<TSelection> | null>(null);
+
+  if (instRef.current === null) {
+    instRef.current = { hasValue: false, value: null };
+  }
+
+  const inst = instRef.current;
+
+  const [getSelection, getServerSelection] = useMemo(() => {
+    let hasMemo = false;
+    let memoizedSnapshot: TSnapshot;
+    let memoizedSelection: TSelection;
+
+    const memoizedSelector = (nextSnapshot: TSnapshot): TSelection => {
+      if (!hasMemo) {
+        hasMemo = true;
+        memoizedSnapshot = nextSnapshot;
+        const nextSelection = selector(nextSnapshot);
+
+        if (isEqual !== undefined && inst.hasValue) {
+          const currentSelection = inst.value as TSelection;
+          if (isEqual(currentSelection, nextSelection)) {
+            memoizedSelection = currentSelection;
+            return currentSelection;
+          }
+        }
+
+        memoizedSelection = nextSelection;
+        return nextSelection;
+      }
+
+      const currentSelection = memoizedSelection;
+
+      if (objectIs(memoizedSnapshot, nextSnapshot)) {
+        return currentSelection;
+      }
+
+      const nextSelection = selector(nextSnapshot);
+
+      if (isEqual !== undefined && isEqual(currentSelection, nextSelection)) {
+        memoizedSnapshot = nextSnapshot;
+        return currentSelection;
+      }
+
+      memoizedSnapshot = nextSnapshot;
+      memoizedSelection = nextSelection;
+      return nextSelection;
+    };
+
+    const getSnapshotWithSelector = () => memoizedSelector(getSnapshot());
+    const getServerSnapshotWithSelector =
+      getServerSnapshot === undefined
+        ? undefined
+        : () => memoizedSelector(getServerSnapshot());
+
+    return [getSnapshotWithSelector, getServerSnapshotWithSelector] as const;
+  }, [getSnapshot, getServerSnapshot, selector, isEqual, inst]);
+
+  const value = useSyncExternalStore(
+    subscribe,
+    getSelection,
+    getServerSelection,
+  );
+
+  useEffect(() => {
+    inst.hasValue = true;
+    inst.value = value;
+  }, [inst, value]);
+
+  useDebugValue(value);
+
+  return value;
+}
+
+export default {
+  useSyncExternalStoreWithSelector,
+};

package/src/shared/shims/util.ts

@@ -0,0 +1,229 @@
+/**
+ * Node.js util module polyfill for browser environment.
+ * Required by adaptivecards-templating and antlr4ts.
+ *
+ * @module @burdenoff/fe-libs/shared/shims/util
+ */
+
+export function isPromise(value: unknown): value is Promise<unknown> {
+  return (
+    value !== null &&
+    typeof value === "object" &&
+    typeof (value as Promise<unknown>).then === "function" &&
+    typeof (value as Promise<unknown>).catch === "function"
+  );
+}
+
+export function isDate(value: unknown): value is Date {
+  return value instanceof Date;
+}
+
+export function isError(value: unknown): value is Error {
+  return value instanceof Error;
+}
+
+export function isRegExp(value: unknown): value is RegExp {
+  return value instanceof RegExp;
+}
+
+export function isArray(value: unknown): value is unknown[] {
+  return Array.isArray(value);
+}
+
+export function isBuffer(_value: unknown): boolean {
+  return false;
+}
+
+export function isNullOrUndefined(value: unknown): value is null | undefined {
+  return value === null || value === undefined;
+}
+
+export function isUndefined(value: unknown): value is undefined {
+  return value === undefined;
+}
+
+export function isNull(value: unknown): value is null {
+  return value === null;
+}
+
+export function isBoolean(value: unknown): value is boolean {
+  return typeof value === "boolean";
+}
+
+export function isNumber(value: unknown): value is number {
+  return typeof value === "number";
+}
+
+export function isString(value: unknown): value is string {
+  return typeof value === "string";
+}
+
+export function isSymbol(value: unknown): value is symbol {
+  return typeof value === "symbol";
+}
+
+export function isObject(value: unknown): value is object {
+  return typeof value === "object" && value !== null;
+}
+
+export function isFunction(
+  value: unknown,
+): value is (...args: unknown[]) => unknown {
+  return typeof value === "function";
+}
+
+export function isPrimitive(value: unknown): boolean {
+  return (
+    value === null || (typeof value !== "object" && typeof value !== "function")
+  );
+}
+
+export const inspect = {
+  custom: Symbol.for("nodejs.util.inspect.custom"),
+};
+
+export function format(fmt: string, ...args: unknown[]): string {
+  let i = 0;
+  return fmt.replace(/%[sdjifoO%]/g, (match) => {
+    if (match === "%%") return "%";
+    if (i >= args.length) return match;
+    const arg = args[i++];
+    switch (match) {
+      case "%s":
+        return String(arg);
+      case "%d":
+        return String(Number(arg));
+      case "%i":
+        return String(parseInt(String(arg), 10));
+      case "%f":
+        return String(parseFloat(String(arg)));
+      case "%j":
+        return JSON.stringify(arg);
+      case "%o":
+      case "%O":
+        return JSON.stringify(arg, null, 2);
+      default:
+        return String(arg);
+    }
+  });
+}
+
+export function inherits(
+  ctor: { prototype: object; super_?: unknown },
+  superCtor: { prototype: object },
+): void {
+  ctor.super_ = superCtor;
+  Object.setPrototypeOf(ctor.prototype, superCtor.prototype);
+}
+
+export function deprecate<T extends (...args: unknown[]) => unknown>(
+  fn: T,
+  _msg: string,
+): T {
+  return fn;
+}
+
+export function promisify<T>(
+  fn: (...args: unknown[]) => void,
+): (...args: unknown[]) => Promise<T> {
+  return (...args: unknown[]) =>
+    new Promise((resolve, reject) => {
+      fn(...args, (err: Error | null, result: T) => {
+        if (err) reject(err);
+        else resolve(result);
+      });
+    });
+}
+
+export function callbackify<T>(
+  fn: (...args: unknown[]) => Promise<T>,
+): (...args: [...unknown[], (err: Error | null, result?: T) => void]) => void {
+  return (...args) => {
+    const callback = args.pop() as (err: Error | null, result?: T) => void;
+    Promise.resolve(fn(...args))
+      .then((result) => callback(null, result))
+      .catch((err) => callback(err));
+  };
+}
+
+export const types = {
+  isPromise,
+  isDate,
+  isRegExp,
+  isArray,
+  isArrayBuffer: (value: unknown): value is ArrayBuffer =>
+    value instanceof ArrayBuffer,
+  isArrayBufferView: (value: unknown): boolean => ArrayBuffer.isView(value),
+  isAsyncFunction: (value: unknown): boolean =>
+    typeof value === "function" && value.constructor.name === "AsyncFunction",
+  isBigInt64Array: (value: unknown): boolean => value instanceof BigInt64Array,
+  isBigUint64Array: (value: unknown): boolean =>
+    value instanceof BigUint64Array,
+  isBooleanObject: (value: unknown): boolean =>
+    typeof value === "object" && value instanceof Boolean,
+  isDataView: (value: unknown): value is DataView => value instanceof DataView,
+  isFloat32Array: (value: unknown): boolean => value instanceof Float32Array,
+  isFloat64Array: (value: unknown): boolean => value instanceof Float64Array,
+  isGeneratorFunction: (value: unknown): boolean =>
+    typeof value === "function" &&
+    value.constructor.name === "GeneratorFunction",
+  isGeneratorObject: (value: unknown): boolean =>
+    typeof value === "object" &&
+    value !== null &&
+    value.constructor.name === "Generator",
+  isInt8Array: (value: unknown): boolean => value instanceof Int8Array,
+  isInt16Array: (value: unknown): boolean => value instanceof Int16Array,
+  isInt32Array: (value: unknown): boolean => value instanceof Int32Array,
+  isMap: (value: unknown): value is Map<unknown, unknown> =>
+    value instanceof Map,
+  isMapIterator: (_value: unknown): boolean => false,
+  isNativeError: isError,
+  isNumberObject: (value: unknown): boolean =>
+    typeof value === "object" && value instanceof Number,
+  isSet: (value: unknown): value is Set<unknown> => value instanceof Set,
+  isSetIterator: (_value: unknown): boolean => false,
+  isSharedArrayBuffer: (value: unknown): boolean =>
+    typeof SharedArrayBuffer !== "undefined" &&
+    value instanceof SharedArrayBuffer,
+  isStringObject: (value: unknown): boolean =>
+    typeof value === "object" && value instanceof String,
+  isSymbolObject: (value: unknown): boolean =>
+    typeof value === "object" && value !== null && value.constructor === Symbol,
+  isTypedArray: (value: unknown): boolean =>
+    ArrayBuffer.isView(value) && !(value instanceof DataView),
+  isUint8Array: (value: unknown): boolean => value instanceof Uint8Array,
+  isUint8ClampedArray: (value: unknown): boolean =>
+    value instanceof Uint8ClampedArray,
+  isUint16Array: (value: unknown): boolean => value instanceof Uint16Array,
+  isUint32Array: (value: unknown): boolean => value instanceof Uint32Array,
+  isWeakMap: (value: unknown): value is WeakMap<object, unknown> =>
+    value instanceof WeakMap,
+  isWeakSet: (value: unknown): value is WeakSet<object> =>
+    value instanceof WeakSet,
+};
+
+export default {
+  isPromise,
+  isDate,
+  isError,
+  isRegExp,
+  isArray,
+  isBuffer,
+  isNullOrUndefined,
+  isUndefined,
+  isNull,
+  isBoolean,
+  isNumber,
+  isString,
+  isSymbol,
+  isObject,
+  isFunction,
+  isPrimitive,
+  inspect,
+  format,
+  inherits,
+  deprecate,
+  promisify,
+  callbackify,
+  types,
+};