@occultist/extensions 0.0.1

package/lib/static/dependancy-graph.ts

@@ -0,0 +1,101 @@
+import type {FileInfo} from "./file-info.ts";
+import type {PolicyDirective, ReferenceDetails} from "./types.ts";
+
+
+export class DependancyMap {
+  file: FileInfo;
+  references: ReferenceDetails[];
+  polices: Map<PolicyDirective, ReferenceDetails[]> = new Map();
+
+  constructor(file: FileInfo, references: ReferenceDetails[]) {
+    this.file = file;
+    this.references = references;
+  }
+
+  finalize() {
+    let reference: ReferenceDetails;
+    let policies: ReferenceDetails[];
+
+    for (let i = 0; i < this.references.length; i++) {
+      reference = this.references[i];
+      policies = this.polices.get(reference.directive);
+
+      if (policies == null) {
+        policies = [];
+        this.polices.set(reference.directive, policies);
+      }
+
+      policies.push(reference);
+    }
+  }
+}
+
+export class DependancyGraph {
+  dependancies: Map<string, DependancyMap> = new Map();
+  
+  constructor(dependancies: Map<string, DependancyMap>) {
+    this.dependancies = dependancies;
+
+    for (const dependancyMap of this.dependancies.values()) {
+      for (let i = 0; i < dependancyMap.references.length; i++) {
+        const reference = dependancyMap.references[i];
+
+        if (reference.file == null) {
+          console.warn(`Unknown dependancy reference ${reference.url}`);
+          
+          continue;
+        }
+
+        const other = this.dependancies.get(reference.file.alias);
+
+        if (other == null) {
+          continue;
+        }
+     
+        for (let j = 0; j < other.references.length; j++) {
+          dependancyMap.references.push(other.references[j]);
+        }
+      }
+
+      dependancyMap.finalize();
+    }
+    
+    Object.freeze(this.dependancies);
+    Object.freeze(this);
+  }
+
+  /**
+   * Returns a debug string for this dependancy graph.
+   */
+  debug(): string {
+    let debug = 'Dependancy Graph\n----------------\n\n';
+    let dependancy: DependancyMap;
+    const dependancies = Array.from(this.dependancies.values());
+
+    for (let i = 0; i < dependancies.length; i++) {
+      if (i !== 0) debug += '\n';
+
+      dependancy = dependancies[i];
+      debug += dependancy.file.alias + '\n';
+
+      const polices = Array.from(dependancy.polices.entries());
+      
+      if (polices.length === 0) {
+        debug += `  No dependancies\n`;
+        continue;
+      }
+      
+      for (const [policy, references] of dependancy.polices.entries()) {
+        debug += `  ${policy}\n`;
+
+        for (let j = 0; j < references.length; j++) {
+          debug += `    ${references[j].url}\n`;
+        }
+      }
+    }
+
+    debug += '----------------\n';
+    return debug;
+  }
+}
+

package/lib/static/file-info.ts

@@ -0,0 +1,153 @@
+import {join} from "node:path";
+
+export type FileInfo = {
+
+  /**
+   * The name of the file.
+   */
+  name: string;
+
+  /**
+   * Path of the file relative to the configured directory.
+   */
+  relativePath: string;
+
+  /**
+   * Full path to the file.
+   */
+  absolutePath: string;
+
+  /**
+   * The alias to the directory where the file is located in.
+   */
+  directoryAlias: string;
+
+  /**
+   * The file's extension.
+   */
+  extension: string;
+
+  /**
+   * The file's language if detected.
+   */
+  lang?: string;
+
+  /**
+   * The file's content type.
+   */
+  contentType: string;
+
+  /**
+   * This files directory + relative path + name.
+   */
+  alias: string;
+
+  /**
+   * The hash of the original file contents.
+   */
+  hash: string;
+
+  /**
+   * The URL of the file.
+   */
+  url: string;
+
+  /**
+   * alias url for this resource.
+   */
+  aliasURL: string;
+
+}
+
+/**
+ * Contains information about a static file.
+ */
+export class WorkingFileInfo {
+
+  /**
+   * The name of the file.
+   */
+  name: string;
+
+  /**
+   * Path of the file relative to the configured directory.
+   */
+  relativePath: string;
+
+  /**
+   * Full path to the file.
+   */
+  absolutePath: string;
+
+  /**
+   * The alias to the directory where the file is located in.
+   */
+  directoryAlias: string;
+
+  /**
+   * The file's extension.
+   */
+  extension: string;
+
+  /**
+   * The file's language if detected.
+   */
+  lang?: string;
+
+  /**
+   * The file's content type.
+   */
+  contentType: string;
+
+  /**
+   * This files directory + relative path + name.
+   */
+  alias: string;
+
+  /**
+   * The hash of the original file contents.
+   */
+  hash: string | null = null;
+
+  /**
+   * The URL of the file.
+   */
+  url: string | null = null;
+
+  /**
+   * alias url for this resource.
+   */
+  aliasURL: string | null = null;
+
+  constructor(
+    name: string,
+    directoryAlias: string,
+    relativePath: string,
+    absolutePath: string,
+    extension: string,
+    contentType: string,
+    lang?: string,
+  ) {
+    this.name = name;
+    this.directoryAlias = directoryAlias
+    this.relativePath = relativePath;
+    this.absolutePath = absolutePath;
+    this.extension = extension;
+    this.contentType = contentType;
+    this.lang = lang;
+    this.alias = join(directoryAlias, relativePath);
+  }
+
+  finalize(
+    hash: string,
+    url: string,
+    aliasURL: string,
+  ) {
+    this.hash = hash;
+    this.url = url;
+    this.aliasURL = aliasURL;
+
+    Object.freeze(this);
+  }
+
+}

package/lib/static/html-parser.ts

@@ -0,0 +1,225 @@
+import {readFile} from "fs/promises";
+import {DependancyMap} from "./dependancy-graph.ts";
+import {type FileInfo} from "./file-info.ts";
+import type {PolicyDirective, ReferenceDetails, ReferenceParser} from "./types.ts";
+import { JSDOM } from 'jsdom';
+
+
+const asMap: Record<string, PolicyDirective> = {
+  audio: 'media-src',
+  document: 'frame-src',
+  embed: 'object-src',
+  fetch: 'connect-src',
+  font: 'font-src',
+  image: 'img-src',
+  object: 'object-src',
+  script: 'script-src',
+  style: 'style-src',
+  track: 'media-src',
+  video: 'media-src',
+  worker: 'worker-src',
+};
+
+export type HTMLParserArgs = {
+  contentType?: string | string[];
+};
+
+export class HTMLParser implements ReferenceParser {
+  supports: Set<string> = new Set([
+    'text/html',
+    'application/xhtml+xml',
+  ]);
+
+  constructor(args: HTMLParserArgs = {}) {
+    if (Array.isArray(args?.contentType)) {
+      this.supports = new Set(args.contentType);
+    } else if (args?.contentType != null) {
+      this.supports = new Set([args.contentType]);
+    }
+  }
+
+  async parse(
+    content: Blob,
+    file: FileInfo,
+    filesByURL: Map<string, FileInfo>,
+  ): Promise<ReferenceDetails[]> {
+    let references: ReferenceDetails[] = [];
+    let src: string;
+    let rel: string;
+    let as: string;
+    let url: string;
+    const text = await content.text();
+    const dom = new JSDOM(text, {
+      contentType: file.contentType,
+    });
+    const document = dom.window.document;
+
+    for (const element of document.querySelectorAll('link')) {
+      src = element.getAttribute('src');
+      rel = element.getAttribute('rel');
+      as = element.getAttribute('as');
+      url = new URL(src, file.aliasURL).toString();
+
+      if (rel === 'stylesheet') {
+        references.push({
+          url,
+          directive: 'style-src',
+          file: filesByURL.get(url),
+        });
+
+        continue;
+      }
+
+      if (Object.hasOwn(asMap, as)) {
+        references.push({
+          url,
+          directive: asMap[as],
+          file: filesByURL.get(url),
+        });
+
+        continue;
+      }
+        
+      references.push({
+        url,
+        file: filesByURL.get(url),
+      });
+    }
+
+    for (const element of [
+      ...document.querySelectorAll('img'),
+      ...document.querySelectorAll('picture source'),
+    ]) {
+      src = element.tagName.toLowerCase() === 'source'
+        ? element.getAttribute('srcset')
+        : element.getAttribute('src')
+
+      if (src == null) {
+        continue;
+      }
+
+      url = new URL(src, file.aliasURL).toString();
+
+      references.push({
+        url,
+        directive: 'img-src',
+        file: filesByURL.get(url),
+      });
+    }
+
+    for (const element of [
+      ...document.querySelectorAll('track'),
+      ...document.querySelectorAll('audio'),
+      ...document.querySelectorAll('video'),
+      ...document.querySelectorAll('video source'),
+    ]) {
+      src = element.getAttribute('src');
+
+      if (src == null) {
+        continue;
+      }
+
+      url = new URL(src, file.aliasURL).toString();
+
+      references.push({
+        url,
+        directive: 'media-src',
+        file: filesByURL.get(url),
+      });
+    }
+
+    for (const element of [
+      ...document.querySelectorAll('iframe'),
+      ...document.querySelectorAll('fencedframe'),
+    ]) {
+      src = element.getAttribute('src');
+
+      if (src == null) {
+        continue;
+      }
+
+      url = new URL(src, file.aliasURL).toString();
+
+      references.push({
+        url,
+        directive: 'child-src',
+        file: filesByURL.get(url),
+      });
+    }
+
+    for (const element of document.querySelectorAll('script')) {
+      src = element.getAttribute('src');
+
+      if (src == null) {
+        continue;
+      }
+
+      url = new URL(src, file.aliasURL).toString();
+
+      references.push({
+        url,
+        directive: 'script-src',
+        file: filesByURL.get(url),
+      });
+    }
+
+    return references;
+  }
+
+  async update(
+    content: Blob,
+    file: FileInfo,
+    filesByURL: Map<string, FileInfo>,
+  ): Promise<Blob> {
+    let url: string | undefined;
+    let ref: FileInfo | undefined;
+    let text = await content.text();
+    const dom = new JSDOM(text, {
+      contentType: file.contentType,
+    });
+    const document = dom.window.document;
+
+    for (const element of [
+      ...document.querySelectorAll('link'),
+      ...document.querySelectorAll('img'),
+      ...document.querySelectorAll('track'),
+      ...document.querySelectorAll('audio'),
+      ...document.querySelectorAll('video'),
+      ...document.querySelectorAll('video source'),
+      ...document.querySelectorAll('iframe'),
+      ...document.querySelectorAll('fencedframe'),
+      ...document.querySelectorAll('script'),
+    ]) {
+      const src = element.getAttribute('src');
+
+      if (src == null) {
+        continue;
+      }
+
+      url = new URL(src, file.aliasURL).toString();
+      ref = filesByURL.get(url);
+
+      if (ref == null) continue;
+
+      element.setAttribute('src', ref.url);
+    }
+
+    for (const element of document.querySelectorAll('picture source')) {
+      const src = element.getAttribute('srcset');
+
+      if (src == null) {
+        continue;
+      }
+
+      url = new URL(src, file.aliasURL).toString();
+      ref = filesByURL.get(url);
+
+      if (ref == null) continue;
+
+      element.setAttribute('srcset', ref.url);
+    }
+
+    return new Blob([dom.serialize()], { type: file.contentType });
+  }
+
+}

package/lib/static/js-parser.ts

@@ -0,0 +1,107 @@
+import {parse, type ImportDeclaration, type ImportExpression, type Literal, type Node, type Options} from 'acorn';
+import {generate} from 'astring';
+import {walk} from 'zimmerframe';
+import {type FileInfo} from "./file-info.ts";
+import type {FilesByURL, ReferenceDetails, ReferenceParser} from "./types.ts";
+
+
+export type JSReferenceParserArgs = {
+  contentType?: string | string[];
+  acornOptions?: Options;
+};
+
+export class JSReferenceParser implements ReferenceParser {
+  
+  supports: Set<string> = new Set(['application/javascript']);
+
+  #acornOptions: Options;
+
+  constructor(args: JSReferenceParserArgs = {}) {
+    if (Array.isArray(args?.contentType)) {
+      this.supports = new Set(args.contentType);
+    } else if (args?.contentType != null) {
+      this.supports = new Set([args.contentType]);
+    }
+
+    this.#acornOptions = args.acornOptions ?? {
+      ecmaVersion: 'latest',
+      sourceType: 'module',
+    };
+  }
+
+  async parse(
+    content: Blob,
+    file: FileInfo,
+    filesByURL: FilesByURL,
+  ): Promise<ReferenceDetails[]> {
+    let references: ReferenceDetails[] = [];
+    let url: string;
+    const text = await content.text();
+    const ast = parse(text, this.#acornOptions);
+    
+    walk(ast as Node, {}, {
+      ImportDeclaration(node: ImportDeclaration, { next }) {
+        url = new URL((node.source as Literal).value as string, file.aliasURL).toString();
+        
+        references.push({
+          url,
+          directive: 'script-src',
+          file: filesByURL.get(url),
+        });
+
+        next();
+      },
+      ImportExpression(node: ImportExpression, { next }) {
+        url = new URL((node.source as Literal).value as string, file.aliasURL).toString();
+        
+        references.push({
+          url,
+          directive: 'script-src',
+          file: filesByURL.get(url),
+        });
+
+        next();
+      },
+    });
+
+    return references;
+  }
+
+  async update(
+    content: Blob,
+    file: FileInfo,
+    filesByURL: Map<string, FileInfo>,
+  ): Promise<Blob> {
+    let url: string | undefined;
+    let ref: FileInfo | undefined;
+    const text = await content.text();
+    const ast = parse(text, this.#acornOptions);
+    const updated = walk(ast as Node, {}, {
+      ImportDeclaration(node: ImportDeclaration, { next }) {
+        url = new URL((node.source as Literal).value as string, file.aliasURL).toString();
+        ref = filesByURL.get(url);
+
+        if (ref == null) return;
+
+        const source = node.source as Literal;
+        source.raw = '"' + encodeURI(ref.url) + '"';
+
+        next();
+      },
+      ImportExpression(node: ImportExpression, { next }) {
+        url = new URL((node.source as Literal).value as string, file.aliasURL).toString();
+        ref = filesByURL.get(url);
+
+        if (ref == null) return;
+
+        const source = node.source as Literal;
+        source.raw = '"' + encodeURI(ref.url) + '"';
+
+        next();
+      },
+    });
+    const serialized = generate(updated);
+
+    return new Blob([serialized], { type: file.contentType });
+  }
+}