@veryfront/ext-css-purgecss 0.1.1186 → 0.1.1188

package/esm/deno.d.ts

@@ -0,0 +1,28 @@
+declare namespace _default {
+    let name: string;
+    let version: string;
+    let exports: string;
+    namespace veryfront {
+        let extension: boolean;
+        let activation: string;
+        namespace contracts {
+            let provides: string[];
+        }
+        let capabilities: {
+            type: string;
+            apis: string[];
+        }[];
+    }
+    let imports: {
+        purgecss: string;
+        "@std/assert": string;
+        "@std/testing/bdd": string;
+        "veryfront/extensions": string;
+        "veryfront/extensions/css": string;
+    };
+    namespace tasks {
+        let test: string;
+    }
+}
+export default _default;
+//# sourceMappingURL=deno.d.ts.map

package/esm/deno.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deno.d.ts","sourceRoot":"","sources":["../src/deno.js"],"names":[],"mappings":""}

package/esm/deno.js

@@ -0,0 +1,23 @@
+export default {
+    "name": "@veryfront/ext-css-purgecss",
+    "version": "0.1.0",
+    "exports": "./src/index.ts",
+    "veryfront": {
+        "extension": true,
+        "activation": "explicit",
+        "contracts": {
+            "provides": ["CSSPurgingEngine"]
+        },
+        "capabilities": [{ "type": "system:read", "apis": ["cpus"] }]
+    },
+    "imports": {
+        "purgecss": "npm:purgecss@8.0.0",
+        "@std/assert": "jsr:@std/assert@1.0.19",
+        "@std/testing/bdd": "jsr:@std/testing@1.0.17/bdd",
+        "veryfront/extensions": "../../src/extensions/types.ts",
+        "veryfront/extensions/css": "../../src/extensions/css/index.ts"
+    },
+    "tasks": {
+        "test": "deno test --frozen --no-check --allow-sys=cpus src/"
+    }
+};

package/esm/src/index.d.ts

@@ -0,0 +1,6 @@
+/** PurgeCSS implementation of the provider-neutral CSS purging contract. */
+import "../_dnt.polyfills.js";
+import type { ExtensionFactory } from "veryfront/extensions";
+declare const extCSSPurgeCSS: ExtensionFactory;
+export default extCSSPurgeCSS;
+//# sourceMappingURL=index.d.ts.map

package/esm/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/src/index.ts"],"names":[],"mappings":"AAAA,4EAA4E;AAC5E,OAAO,sBAAsB,CAAC;AAG9B,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AA6P7D,QAAA,MAAM,cAAc,EAAE,gBAerB,CAAC;AAEF,eAAe,cAAc,CAAC"}

package/esm/src/index.js

@@ -0,0 +1,220 @@
+/** PurgeCSS implementation of the provider-neutral CSS purging contract. */
+import "../_dnt.polyfills.js";
+import { CSSPurgingEngineName, } from "veryfront/extensions/css";
+import { PurgeCSS } from "purgecss";
+import extensionPackage from "../deno.js";
+const arrayIsArray = Array.isArray;
+const freeze = Object.freeze;
+const getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
+const getOwnPropertyDescriptors = Object.getOwnPropertyDescriptors;
+const getPrototypeOf = Object.getPrototypeOf;
+const hasOwn = Object.hasOwn;
+const objectPrototype = Object.prototype;
+const ownKeys = Reflect.ownKeys;
+const executeRegularExpression = RegExp.prototype.exec;
+const apply = Reflect.apply;
+const purgeCSSPurge = PurgeCSS.prototype.purge;
+const EXACT_NPM_SPECIFIER_PATTERN = /^npm:purgecss@((?:0|[1-9]\d*)\.(?:0|[1-9]\d*)\.(?:0|[1-9]\d*))$/;
+const ENGINE_SEMANTICS_VERSION = "veryfront.css-purgecss.v1";
+const PROVIDER_RESULT_KEYS = freeze([
+    "css",
+    "file",
+    "rejectedCss",
+]);
+function dependencyVersion(specifier) {
+    const match = apply(executeRegularExpression, EXACT_NPM_SPECIFIER_PATTERN, [
+        specifier,
+    ]);
+    if (match?.[1] === undefined) {
+        throw new TypeError("ext-css-purgecss dependency must use an exact npm version");
+    }
+    return match[1];
+}
+function assertEmptyConfig(value) {
+    if (value === undefined)
+        return;
+    if (typeof value !== "object" || value === null) {
+        throw new TypeError("ext-css-purgecss config must be an object");
+    }
+    let isArray;
+    let prototype;
+    let keys;
+    try {
+        isArray = arrayIsArray(value);
+        prototype = getPrototypeOf(value);
+        keys = ownKeys(getOwnPropertyDescriptors(value));
+    }
+    catch (cause) {
+        throw new TypeError("ext-css-purgecss config could not be inspected", {
+            cause,
+        });
+    }
+    if (isArray) {
+        throw new TypeError("ext-css-purgecss config must be an object");
+    }
+    if (prototype !== objectPrototype && prototype !== null) {
+        throw new TypeError("ext-css-purgecss config must not inherit configuration");
+    }
+    if (keys.length !== 0) {
+        throw new TypeError("ext-css-purgecss does not accept configuration properties");
+    }
+}
+function inspectArray(value, label) {
+    try {
+        return arrayIsArray(value);
+    }
+    catch (cause) {
+        throw new TypeError(`${label} could not be inspected`, { cause });
+    }
+}
+function descriptorValue(value, property, label, required, enumerable = true) {
+    let descriptor;
+    try {
+        descriptor = getOwnPropertyDescriptor(value, property);
+    }
+    catch (cause) {
+        throw new TypeError(`${label} could not be inspected`, { cause });
+    }
+    if (descriptor === undefined) {
+        if (!required)
+            return undefined;
+        throw new TypeError(`${label} must define ${property}`);
+    }
+    if (!hasOwn(descriptor, "value") || descriptor.enumerable !== enumerable) {
+        throw new TypeError(`${label} ${property} must be an own data property`);
+    }
+    return descriptor.value;
+}
+function copyContent(content) {
+    const copied = [];
+    for (let index = 0; index < content.length; index++) {
+        const source = content[index];
+        copied[index] = { raw: source.raw, extension: source.extension };
+    }
+    return copied;
+}
+function copyStrings(values) {
+    const copied = [];
+    for (let index = 0; index < values.length; index++) {
+        copied[index] = values[index];
+    }
+    return copied;
+}
+function providerResult(value, includeRejectedCSS) {
+    if (!inspectArray(value, "PurgeCSS result")) {
+        throw new TypeError("PurgeCSS returned a non-array result");
+    }
+    const length = descriptorValue(value, "length", "PurgeCSS result", true, false);
+    if (length !== 1) {
+        throw new TypeError("PurgeCSS must return exactly one result");
+    }
+    let arrayKeys;
+    try {
+        arrayKeys = ownKeys(getOwnPropertyDescriptors(value));
+    }
+    catch (cause) {
+        throw new TypeError("PurgeCSS result could not be inspected", { cause });
+    }
+    let hasEntry = false;
+    let hasLength = false;
+    for (let index = 0; index < arrayKeys.length; index++) {
+        if (arrayKeys[index] === "0")
+            hasEntry = true;
+        if (arrayKeys[index] === "length")
+            hasLength = true;
+    }
+    if (arrayKeys.length !== 2 || !hasEntry || !hasLength) {
+        throw new TypeError("PurgeCSS returned unsupported result entries");
+    }
+    const entry = descriptorValue(value, "0", "PurgeCSS result", true);
+    if (typeof entry !== "object" ||
+        entry === null ||
+        inspectArray(entry, "PurgeCSS result entry")) {
+        throw new TypeError("PurgeCSS returned an invalid result entry");
+    }
+    let keys;
+    try {
+        keys = ownKeys(getOwnPropertyDescriptors(entry));
+    }
+    catch (cause) {
+        throw new TypeError("PurgeCSS result entry could not be inspected", {
+            cause,
+        });
+    }
+    for (let keyIndex = 0; keyIndex < keys.length; keyIndex++) {
+        const key = keys[keyIndex];
+        let allowed = false;
+        for (let index = 0; index < PROVIDER_RESULT_KEYS.length; index++) {
+            if (PROVIDER_RESULT_KEYS[index] === key) {
+                allowed = true;
+                break;
+            }
+        }
+        if (!allowed) {
+            throw new TypeError("PurgeCSS returned unsupported result properties");
+        }
+    }
+    const css = descriptorValue(entry, "css", "PurgeCSS result entry", true);
+    if (typeof css !== "string") {
+        throw new TypeError("PurgeCSS result css must be a string");
+    }
+    const file = descriptorValue(entry, "file", "PurgeCSS result entry", false);
+    if (file !== undefined) {
+        throw new TypeError("PurgeCSS returned an unexpected file-backed result");
+    }
+    let rejectedDescriptor;
+    try {
+        rejectedDescriptor = getOwnPropertyDescriptor(entry, "rejectedCss");
+    }
+    catch (cause) {
+        throw new TypeError("PurgeCSS result entry could not be inspected", {
+            cause,
+        });
+    }
+    const rejectedCSS = includeRejectedCSS
+        ? descriptorValue(entry, "rejectedCss", "PurgeCSS result entry", true)
+        : undefined;
+    if (includeRejectedCSS && typeof rejectedCSS !== "string") {
+        throw new TypeError("PurgeCSS omitted requested rejected CSS");
+    }
+    if (!includeRejectedCSS && rejectedDescriptor !== undefined) {
+        throw new TypeError("PurgeCSS returned unrequested rejected CSS");
+    }
+    return freeze({
+        css,
+        ...(typeof rejectedCSS === "string" ? { rejectedCSS } : {}),
+    });
+}
+/** Explicit PurgeCSS provider. Invoke it through core's validated session. */
+class PurgeCSSPurgingEngine {
+    cacheIdentity;
+    constructor() {
+        this.cacheIdentity =
+            `${ENGINE_SEMANTICS_VERSION};ext-css-purgecss@${extensionPackage.version};purgecss@${dependencyVersion(extensionPackage.imports.purgecss)}`;
+        freeze(this);
+    }
+    async purge(request) {
+        const results = await apply(purgeCSSPurge, new PurgeCSS(), [{
+                content: copyContent(request.content),
+                css: [{ raw: request.css }],
+                safelist: copyStrings(request.safelist),
+                rejectedCss: request.includeRejectedCSS,
+            }]);
+        return providerResult(results, request.includeRejectedCSS);
+    }
+}
+const extCSSPurgeCSS = (config) => {
+    assertEmptyConfig(config);
+    const engine = new PurgeCSSPurgingEngine();
+    return {
+        name: "ext-css-purgecss",
+        version: extensionPackage.version,
+        contracts: { provides: ["CSSPurgingEngine"] },
+        capabilities: [{ type: "system:read", apis: ["cpus"] }],
+        setup(ctx) {
+            ctx.provide(CSSPurgingEngineName, engine);
+            ctx.logger.debug(`[ext-css-purgecss] ${CSSPurgingEngineName} registered`);
+        },
+    };
+};
+export default extCSSPurgeCSS;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@veryfront/ext-css-purgecss",
-  "version": "0.1.1186",
+  "version": "0.1.1188",
   "description": "Veryfront first-party extension package for ext-css-purgecss",
   "keywords": [
     "veryfront",
@@ -27,7 +27,7 @@
   },
   "scripts": {},
   "engines": {
-    "node": ">=18.0.0"
+    "node": ">=22.3.0"
   },
   "publishConfig": {
     "access": "public"
@@ -53,7 +53,7 @@
     "purgecss": "8.0.0"
   },
   "peerDependencies": {
-    "veryfront": "^0.1.1186"
+    "veryfront": "^0.1.1188"
   },
   "type": "module",
   "types": "./esm/src/index.d.ts",