@internetarchive/collection-browser 4.5.2 → 4.6.0

package/.claude/worktrees/WEBDEV-8677-bump-field-parsers/test/utils/format-count.test.ts

@@ -0,0 +1,32 @@
+import { expect } from '@open-wc/testing';
+import { formatCount } from '../../src/utils/format-count';
+
+const testCount = 805342;
+
+describe('formatCount', () => {
+  it('returns blank when undefined number', () => {
+    expect(formatCount(undefined)).to.equal('');
+  });
+
+  it('returns blank when negative number', () => {
+    expect(formatCount(testCount * -1)).to.equal('');
+  });
+
+  it('returns long number when no NumberFormat', () => {
+    expect(formatCount(testCount)).to.equal('805,342');
+  });
+
+  it('returns short number when short NumberFormat', () => {
+    expect(formatCount(testCount, 'short')).to.equal('805K');
+  });
+
+  it('returns decimal when value of significant digits < 10', () => {
+    expect(formatCount(testCount * 10, 'short', 'long')).to.equal(
+      '8.1 million',
+    );
+  });
+
+  it('returns locale formatted number', () => {
+    expect(formatCount(testCount, 'long', 'long', 'de-DE')).to.equal('805.342');
+  });
+});

package/.claude/worktrees/WEBDEV-8677-bump-field-parsers/test/utils/format-date.test.ts

@@ -0,0 +1,89 @@
+import { expect } from '@open-wc/testing';
+import { formatDate } from '../../src/utils/format-date';
+
+const testDate = new Date(2020, 11, 9);
+
+describe('formatDate', () => {
+  it('returns blank when undefined date', () => {
+    expect(formatDate(undefined)).to.equal('');
+  });
+
+  it('returns short date when no DateFormat', () => {
+    expect(formatDate(testDate)).to.equal('Dec 2020');
+  });
+
+  it('returns long date when long DateFormat', () => {
+    expect(formatDate(testDate, 'long')).to.equal('Dec 09, 2020');
+  });
+
+  it('returns year-only date when year-only DateFormat', () => {
+    expect(formatDate(testDate, 'year-only')).to.equal('2020');
+  });
+
+  it('returns correct year for old "Jan 1 at midnight" dates and year-only DateFormat', () => {
+    // Many standard timezones have a discontinuity in date parsing at some point during
+    // the 19th or 20th century, corresponding to the creation of the timezone.
+    // Dates prior to the discontinuity generally have a non-hour-aligned timezone offset
+    // which can throw off the calculated year for dates which are close to a year boundary.
+    // This is particularly problematic for "Jan 1 at midnight" dates, which are what we
+    // receive from the search engine for date metadata that only specifies the year.
+    // So we must ensure these older dates still output the correct year, not the prior one.
+    expect(formatDate(new Date('1234-01-01T00:00:00Z'), 'year-only')).to.equal(
+      '1234',
+    );
+  });
+
+  it('uses UTC time zone by default or when useLocalTime is explicitly false', () => {
+    // Default options
+    expect(formatDate(new Date('2025-02-15T00:00:00Z'), 'long')).to.equal(
+      'Feb 15, 2025',
+    );
+    expect(formatDate(new Date('2025-02-15T23:59:59Z'), 'long')).to.equal(
+      'Feb 15, 2025',
+    );
+
+    // Explicit `useLocalTime: false` option
+    const options = { useLocalTime: false };
+    expect(
+      formatDate(new Date('2025-02-15T00:00:00Z'), 'long', options),
+    ).to.equal('Feb 15, 2025');
+    expect(
+      formatDate(new Date('2025-02-15T23:59:59Z'), 'long', options),
+    ).to.equal('Feb 15, 2025');
+  });
+
+  it('uses local time zone when specified', () => {
+    // N.B.:
+    // - Positive offset corresponds to UTC-x zones
+    // - Negative offset corresponds to UTC+x zones
+    const offset = new Date().getTimezoneOffset();
+    const options = { useLocalTime: true };
+
+    // The expected behavior depends on the local time where the tests are run:
+    if (offset > 0) {
+      // If we're testing under a positive offset, the first second of the UTC day should locally fall on the previous day
+      expect(
+        formatDate(new Date('2025-02-15T00:00:00Z'), 'long', options),
+      ).to.equal('Feb 14, 2025');
+    } else if (offset < 0) {
+      // If we're testing under a negative offset, the last second of the UTC day should locally fall on the next day
+      expect(
+        formatDate(new Date('2025-02-15T23:59:59Z'), 'long', options),
+      ).to.equal('Feb 16, 2025');
+    } else {
+      // If we're testing *in* UTC, then both seconds should locally fall on the same day
+      expect(
+        formatDate(new Date('2025-02-15T00:00:00Z'), 'long', options),
+      ).to.equal('Feb 15, 2025');
+      expect(
+        formatDate(new Date('2025-02-15T23:59:59Z'), 'long', options),
+      ).to.equal('Feb 15, 2025');
+    }
+  });
+
+  it('returns locale formatted date', () => {
+    expect(formatDate(testDate, 'long', { locale: 'de-DE' })).to.equal(
+      '09. Dez. 2020',
+    );
+  });
+});

package/.claude/worktrees/WEBDEV-8677-bump-field-parsers/test/utils/format-unit-size.test.ts

@@ -0,0 +1,21 @@
+import { expect } from '@open-wc/testing';
+import { nothing } from 'lit';
+import { formatUnitSize } from '../../src/utils/format-unit-size';
+
+describe('formatUnitSize', () => {
+  it('returns blank when undefined number', () => {
+    expect(formatUnitSize(undefined, 1)).to.equal(nothing);
+  });
+
+  it('returns collection data is in singular form', () => {
+    expect(formatUnitSize(1025, 1)).to.equal('1 kilobyte');
+  });
+
+  it('return collection size data in kilobytes and plural form', () => {
+    expect(formatUnitSize(15000, 1)).to.equal('14.6 kilobytes');
+  });
+
+  it('return huge collection size data', () => {
+    expect(formatUnitSize(454154654134, 1)).to.equal('423 gigabytes');
+  });
+});

package/.claude/worktrees/WEBDEV-8677-bump-field-parsers/test/utils/local-date-from-utc.test.ts

@@ -0,0 +1,37 @@
+import { expect } from '@open-wc/testing';
+import {
+  localDateFromUTC,
+  isFirstMillisecondOfUTCYear,
+} from '../../src/utils/local-date-from-utc';
+
+describe('localDateFromUTC', () => {
+  it('converts dates from UTC to local timezone', async () => {
+    const date = new Date(1990, 1, 2, 3, 4, 5, 6);
+    const dateFromUTC = new Date(Date.UTC(1990, 1, 2, 3, 4, 5, 6));
+    expect(localDateFromUTC(date).toISOString()).to.equal(
+      dateFromUTC.toISOString(),
+    );
+  });
+});
+
+describe('isFirstMillisecondOfUTCYear', () => {
+  it('returns true when date is exactly Jan 1 at midnight in UTC', async () => {
+    const midnightOnNewYearsDay = new Date('2010-01-01T00:00:00Z');
+    expect(isFirstMillisecondOfUTCYear(midnightOnNewYearsDay)).to.be.true;
+  });
+
+  it('returns false when date is not exactly Jan 1 at midnight in UTC', async () => {
+    const oneMillisecondTooEarly = new Date('2009-12-31T23:59:59.999Z');
+    expect(isFirstMillisecondOfUTCYear(oneMillisecondTooEarly)).to.be.false;
+
+    const oneMillisecondTooLate = new Date('2010-01-01T00:00:00.001Z');
+    expect(isFirstMillisecondOfUTCYear(oneMillisecondTooLate)).to.be.false;
+
+    const middleOfTheYear = new Date('2010-06-01T00:00:00Z');
+    expect(isFirstMillisecondOfUTCYear(middleOfTheYear)).to.be.false;
+  });
+
+  it('returns false when no date provided', async () => {
+    expect(isFirstMillisecondOfUTCYear(undefined)).to.be.false;
+  });
+});

package/.claude/worktrees/WEBDEV-8677-bump-field-parsers/tsconfig.json

@@ -0,0 +1,25 @@
+{
+  "compilerOptions": {
+    "target": "esnext",
+    "module": "esnext",
+    "moduleResolution": "bundler",
+    "noEmitOnError": true,
+    "lib": [
+      "ESNext",
+      "dom",
+      "dom.iterable"
+    ],
+    "strict": true,
+    "esModuleInterop": false,
+    "allowSyntheticDefaultImports": true,
+    "experimentalDecorators": true,
+    "importHelpers": true,
+    "outDir": "dist",
+    "sourceMap": true,
+    "inlineSources": true,
+    "rootDir": "./",
+    "declaration": true,
+    "useDefineForClassFields": false,
+  },
+  "include": ["src", "test", "index.ts", "types"],
+}

package/.claude/worktrees/WEBDEV-8677-bump-field-parsers/types/dompurify.d.ts

@@ -0,0 +1 @@
+declare module 'dompurify';

package/.claude/worktrees/WEBDEV-8677-bump-field-parsers/vite.config.ts

@@ -0,0 +1,29 @@
+import { defineConfig } from 'vite';
+import { resolve } from 'path';
+import basicSsl from '@vitejs/plugin-basic-ssl';
+
+// https://vitejs.dev/config/
+export default defineConfig({
+  base: '',
+  build: {
+    outDir: 'ghpages',
+    manifest: true,
+    rollupOptions: {
+      input: {
+        main: resolve(__dirname, 'index.html'),
+      },
+    },
+  },
+  server: {
+    host: 'local.archive.org',
+    port: 8080,
+    open: true,
+    cors: true,
+  },
+  plugins: [
+    basicSsl({
+      name: 'archive-dev',
+      domains: ['local.archive.org'],
+    }),
+  ],
+});

package/.claude/worktrees/WEBDEV-8677-bump-field-parsers/web-dev-server.config.mjs

@@ -0,0 +1,30 @@
+// import { hmrPlugin, presets } from '@open-wc/dev-server-hmr';
+
+/** Use Hot Module replacement by adding --hmr to the start command */
+const hmr = process.argv.includes('--hmr');
+
+export default /** @type {import('@web/dev-server').DevServerConfig} */ ({
+  nodeResolve: true,
+  open: '/',
+  watch: !hmr,
+
+  /** Compile JS for older browsers. Requires @web/dev-server-esbuild plugin */
+  // esbuildTarget: 'auto'
+
+  /** Set appIndex to enable SPA routing */
+  // appIndex: 'demo/index.html',
+
+  /** Confgure bare import resolve plugin */
+  // nodeResolve: {
+  //   exportConditions: ['browser', 'development']
+  // },
+
+  plugins: [
+    /** Use Hot Module Replacement by uncommenting. Requires @open-wc/dev-server-hmr plugin */
+    // hmr && hmrPlugin({ exclude: ['**/*/node_modules/**/*'], presets: [presets.litElement] }),
+  ],
+
+  http2: true,
+  sslCert: './local.archive.org.cert',
+  sslKey: './local.archive.org.key',
+});

package/.claude/worktrees/WEBDEV-8677-bump-field-parsers/web-test-runner.config.mjs

@@ -0,0 +1,52 @@
+import rollupImage from '@rollup/plugin-image';
+import { rollupAdapter } from '@web/dev-server-rollup';
+// import { playwrightLauncher } from '@web/test-runner-playwright';
+
+const filteredLogs = ['Running in dev mode', 'lit-html is in dev mode'];
+
+export default /** @type {import("@web/test-runner").TestRunnerConfig} */ ({
+  /** Test files to run */
+  files: 'dist/test/**/*.test.js',
+
+  /** Resolve bare module imports */
+  nodeResolve: {
+    exportConditions: ['browser', 'development'],
+  },
+
+  mimeTypes: {
+    '**/*.scss': 'js',
+    '**/*.css': 'js',
+    '**/*.svg': 'js',
+    '**/*.json': 'js',
+  },
+
+  /** Filter out lit dev mode logs */
+  filterBrowserLogs(log) {
+    for (const arg of log.args) {
+      if (typeof arg === 'string' && filteredLogs.some(l => arg.includes(l))) {
+        return false;
+      }
+    }
+    return true;
+  },
+
+  plugins: [rollupAdapter(rollupImage())],
+
+  /** Compile JS for older browsers. Requires @web/dev-server-esbuild plugin */
+  // esbuildTarget: 'auto',
+
+  /** Amount of browsers to run concurrently */
+  // concurrentBrowsers: 2,
+
+  /** Amount of test files per browser to test concurrently */
+  // concurrency: 1,
+
+  /** Browsers to run tests on */
+  // browsers: [
+  //   playwrightLauncher({ product: 'chromium' }),
+  //   playwrightLauncher({ product: 'firefox' }),
+  //   playwrightLauncher({ product: 'webkit' }),
+  // ],
+
+  // See documentation for all available options
+});