@navita/core 0.0.0

package/createRenderer.d.ts

@@ -0,0 +1,15 @@
+import * as fela from 'fela';
+import { StyleRule } from '@navita/types';
+
+declare module 'fela' {
+    type CacheItemIsh = Parameters<Parameters<IRenderer['subscribe']>[number]>[number];
+    interface IRenderer {
+        cache: Record<string, CacheItemIsh>;
+        renderRule(rule: () => StyleRule): string;
+        renderStatic(css: StyleRule, selector: string): void;
+    }
+}
+declare function createRenderer(): fela.IRenderer;
+type Renderer = ReturnType<typeof createRenderer>;
+
+export { Renderer, createRenderer };

package/createRenderer.js

@@ -0,0 +1,325 @@
+'use strict';
+
+var fela = require('fela');
+var felaTools = require('fela-tools');
+var types = require('node:util/types');
+var v8 = require('node:v8');
+
+function _interopNamespaceDefault(e) {
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var v8__namespace = /*#__PURE__*/_interopNamespaceDefault(v8);
+
+const chars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
+const charLength = chars.length;
+function nextString(id, className = '') {
+    if (id <= charLength) {
+        return chars[id - 1] + className;
+    }
+    return nextString(id / charLength | 0, chars[(id - 1) % charLength] + className);
+}
+function generateString(getId, blacklist = []) {
+    const className = nextString(getId());
+    if (blacklist.includes(className.toLowerCase())) {
+        return generateString(getId, blacklist);
+    }
+    return className;
+}
+function className(blacklist = []) {
+    return (renderer)=>{
+        renderer.generateClassName = ()=>{
+            return generateString(renderer.getNextRuleIdentifier, blacklist);
+        };
+        renderer.generateAnimationName = ()=>{
+            return generateString(renderer.getNextKeyframeIdentifier, blacklist);
+        };
+        return renderer;
+    };
+}
+
+function createResult(renderer, filePath, isServer) {
+    const values = renderer.evaluatedResults.get(filePath) || [];
+    if (isServer && renderer.classPropertyList) {
+        // Todo: this is just a POC. It needs to be cleaned up, but it's a different build for
+        //  the server. On the client we'll use browser APIs.
+        //  We're using this class list to be able to merge during runtime.
+        const newResult = (values || []).map((item)=>{
+            if (typeof item === "string") {
+                const rules = item.split(' ').map((x)=>renderer.classPropertyList.has(x) ? [
+                        x,
+                        [
+                            ...renderer.classPropertyList.get(x)
+                        ]
+                    ] : false).filter(Boolean);
+                return `new (require('@navita/css').ClassList)("${item}", ${JSON.stringify(rules)})`;
+            }
+            return JSON.stringify(item);
+        });
+        return `const $$evaluatedValues = [${newResult}];`;
+    }
+    return `const $$evaluatedValues = ${JSON.stringify(values || [])};`;
+}
+function evaluatedResult() {
+    return (renderer)=>{
+        renderer.evaluatedResults = new Map();
+        renderer.setEvaluatedResult = (fileName, index, value)=>{
+            if (!renderer.evaluatedResults.has(fileName)) {
+                renderer.evaluatedResults.set(fileName, []);
+            }
+            renderer.evaluatedResults.get(fileName)[index] = value;
+        };
+        renderer.getResult = (filePath, isServer)=>{
+            const result = createResult(renderer, filePath, isServer || false);
+            return {
+                result,
+                get css () {
+                    return renderer.renderToString?.(filePath) || "";
+                }
+            };
+        };
+        return renderer;
+    };
+}
+
+function isMediaQuery(rule) {
+    return rule.startsWith('@media');
+}
+function isSupportsQuery(rule) {
+    return rule.startsWith('@supports');
+}
+function isPseudoSelector(rule) {
+    return rule.startsWith(':');
+}
+function wrapWith(atRule, query, content) {
+    return query.length > 0 ? `${atRule} ${query} {${content}}` : content;
+}
+function createCssRule(selector, properties) {
+    return `${selector}{${properties.map((rule)=>`${cssifyProperty(rule.property)}: ${rule.value};`).join('')}}`;
+}
+function generateCombinedMediaQuery(currentMediaQuery, nestedMediaQuery) {
+    if (currentMediaQuery.length === 0) {
+        return nestedMediaQuery;
+    }
+    return `${currentMediaQuery} and ${nestedMediaQuery}`;
+}
+function cssifyProperty(property) {
+    return property.replace(/([a-zA-Z])([A-Z])/g, '$1-$2').toLowerCase();
+}
+function isObject(value) {
+    return typeof value === 'object' && !Array.isArray(value);
+}
+function collectAndGroupRules(cssObj, currentSupportsQuery = '', currentMediaQuery = '', currentPseudoSelector = '', groupedRules = {}) {
+    for (const [property, value] of Object.entries(cssObj)){
+        if (!isObject(value)) {
+            if (!groupedRules[currentSupportsQuery]) {
+                groupedRules[currentSupportsQuery] = {};
+            }
+            const supportsGroup = groupedRules[currentSupportsQuery];
+            if (!supportsGroup[currentMediaQuery]) {
+                supportsGroup[currentMediaQuery] = {};
+            }
+            const mediaGroup = supportsGroup[currentMediaQuery];
+            if (!mediaGroup[currentPseudoSelector]) {
+                mediaGroup[currentPseudoSelector] = [];
+            }
+            mediaGroup[currentPseudoSelector].push({
+                property,
+                value
+            });
+            continue;
+        }
+        if (isMediaQuery(property)) {
+            collectAndGroupRules(value, currentSupportsQuery, generateCombinedMediaQuery(currentMediaQuery, property.slice(6).trim()), currentPseudoSelector, groupedRules);
+            continue;
+        }
+        if (isSupportsQuery(property)) {
+            collectAndGroupRules(value, generateCombinedMediaQuery(currentSupportsQuery, property.slice(9).trim()), currentMediaQuery, currentPseudoSelector, groupedRules);
+            continue;
+        }
+        if (isPseudoSelector(property)) {
+            collectAndGroupRules(value, currentSupportsQuery, currentMediaQuery, currentPseudoSelector + property, groupedRules);
+        }
+    }
+    return groupedRules;
+}
+function serializeCss(selector, cssObj) {
+    const processPseudoSelectors = (pseudoSelectors)=>Object.entries(pseudoSelectors).map(([pseudo, properties])=>createCssRule(`${selector}${pseudo}`, properties)).join('');
+    const processMediaQueries = (mediaQueries)=>Object.entries(mediaQueries).map(([media, pseudoSelectors])=>wrapWith('@media', media, processPseudoSelectors(pseudoSelectors))).join('');
+    const rules = collectAndGroupRules(cssObj);
+    return Object.entries(rules).map(([supports, mediaQueries])=>wrapWith('@supports', supports, processMediaQueries(mediaQueries))).join('');
+}
+function nestedStatic() {
+    // Fela doesn't handle nested static styles correctly. This is a workaround for now.
+    // https://github.com/robinweser/fela/issues/876
+    // https://github.com/robinweser/fela/issues/465#issuecomment-594396150
+    // https://github.com/robinweser/fela/issues/863
+    return (renderer)=>{
+        const { renderStatic  } = renderer;
+        renderer.renderStatic = (staticStyle, selector)=>{
+            return renderStatic(serializeCss(selector, staticStyle), undefined);
+        };
+        return renderer;
+    };
+}
+
+function renderToString() {
+    return (renderer)=>{
+        renderer.renderToString = (fileName)=>{
+            if (!renderer.getScopedCache || !renderer.accessedKeys) {
+                return felaTools.renderToString(renderer);
+            }
+            if (fileName) {
+                return felaTools.renderToString({
+                    ...renderer,
+                    cache: renderer.getScopedCache(fileName)
+                });
+            }
+            const newCache = {};
+            for (const keys of renderer.accessedKeys.values()){
+                for (const key of keys){
+                    const item = renderer.cache[key];
+                    if (!item) {
+                        continue;
+                    }
+                    newCache[key] = item;
+                }
+            }
+            return felaTools.renderToString({
+                ...renderer,
+                cache: newCache
+            });
+        };
+        return renderer;
+    };
+}
+
+function scopedCache() {
+    return (renderer)=>{
+        let currentFileName;
+        const ensureCache = ()=>{
+            if (types.isProxy(renderer.cache)) {
+                return;
+            }
+            renderer.cache = new Proxy(renderer.cache, {
+                getOwnPropertyDescriptor (target, key) {
+                    const result = Reflect.getOwnPropertyDescriptor(target, key);
+                    const { accessedKeys  } = renderer;
+                    if (!currentFileName) {
+                        return result;
+                    }
+                    if (!accessedKeys.has(currentFileName)) {
+                        accessedKeys.set(currentFileName, new Set());
+                    }
+                    accessedKeys.get(currentFileName)?.add(key);
+                    return result;
+                }
+            });
+        };
+        renderer.setFilePath = (filePath)=>{
+            currentFileName = filePath;
+            // After we've set the file path, we need to ensure that the cache is a proxy,
+            // and set up to record accessed keys.
+            // Without a filePath, the proxy on the cache doesn't make sense, so this is a good place to do it.
+            ensureCache();
+        };
+        renderer.accessedKeys = new Map();
+        renderer.clearAccessedKeys = (filePath)=>{
+            renderer.accessedKeys.get(filePath)?.clear();
+        };
+        renderer.getScopedCache = (filePath)=>{
+            const { accessedKeys  } = renderer;
+            const newCache = {};
+            if (accessedKeys.has(filePath)) {
+                const keys = accessedKeys.get(filePath);
+                for (const key of keys){
+                    const item = renderer.cache[key];
+                    if (!item) {
+                        continue;
+                    }
+                    newCache[key] = item;
+                }
+            }
+            return newCache;
+        };
+        renderer.classPropertyList = new Map();
+        renderer.subscribe((message)=>{
+            if (message.type === 'RULE') {
+                const { declaration , className  } = message;
+                const [property] = declaration.split(':');
+                if (!property) {
+                    return;
+                }
+                const { classPropertyList  } = renderer;
+                if (!classPropertyList.has(className)) {
+                    classPropertyList.set(className, new Set());
+                }
+                classPropertyList.get(className)?.add(property);
+            }
+        });
+        return renderer;
+    };
+}
+
+function serializedCache(keys = []) {
+    return (renderer)=>{
+        renderer.serialize = ()=>{
+            const obj = {};
+            for (const key of keys){
+                const value = renderer[key];
+                if (types.isProxy(value)) {
+                    obj[key] = Object.assign({}, value);
+                } else {
+                    obj[key] = value;
+                }
+            }
+            return v8__namespace.serialize(obj).toString('base64');
+        };
+        renderer.deserialize = (serialized)=>{
+            if (!serialized) {
+                return;
+            }
+            const data = v8__namespace.deserialize(Buffer.from(serialized, 'base64'));
+            for (const [key, value] of Object.entries(data)){
+                renderer[key] = value;
+            }
+        };
+        return renderer;
+    };
+}
+
+function createRenderer() {
+    return fela.createRenderer({
+        enhancers: [
+            className([
+                'ad'
+            ]),
+            scopedCache(),
+            serializedCache([
+                'cache',
+                'classPropertyList',
+                'accessedKeys',
+                'uniqueRuleIdentifier',
+                'uniqueKeyframeIdentifier'
+            ]),
+            evaluatedResult(),
+            renderToString(),
+            nestedStatic()
+        ]
+    });
+}
+
+exports.createRenderer = createRenderer;

package/createRenderer.mjs

@@ -0,0 +1,306 @@
+import { createRequire as createRequire$1 } from 'module';
+const require = createRequire$1(import.meta.url);
+import { createRenderer as createRenderer$1 } from 'fela';
+import { renderToString as renderToString$1 } from 'fela-tools';
+import { isProxy } from 'node:util/types';
+import * as v8 from 'node:v8';
+
+const chars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
+const charLength = chars.length;
+function nextString(id, className = '') {
+    if (id <= charLength) {
+        return chars[id - 1] + className;
+    }
+    return nextString(id / charLength | 0, chars[(id - 1) % charLength] + className);
+}
+function generateString(getId, blacklist = []) {
+    const className = nextString(getId());
+    if (blacklist.includes(className.toLowerCase())) {
+        return generateString(getId, blacklist);
+    }
+    return className;
+}
+function className(blacklist = []) {
+    return (renderer)=>{
+        renderer.generateClassName = ()=>{
+            return generateString(renderer.getNextRuleIdentifier, blacklist);
+        };
+        renderer.generateAnimationName = ()=>{
+            return generateString(renderer.getNextKeyframeIdentifier, blacklist);
+        };
+        return renderer;
+    };
+}
+
+function createResult(renderer, filePath, isServer) {
+    const values = renderer.evaluatedResults.get(filePath) || [];
+    if (isServer && renderer.classPropertyList) {
+        // Todo: this is just a POC. It needs to be cleaned up, but it's a different build for
+        //  the server. On the client we'll use browser APIs.
+        //  We're using this class list to be able to merge during runtime.
+        const newResult = (values || []).map((item)=>{
+            if (typeof item === "string") {
+                const rules = item.split(' ').map((x)=>renderer.classPropertyList.has(x) ? [
+                        x,
+                        [
+                            ...renderer.classPropertyList.get(x)
+                        ]
+                    ] : false).filter(Boolean);
+                return `new (require('@navita/css').ClassList)("${item}", ${JSON.stringify(rules)})`;
+            }
+            return JSON.stringify(item);
+        });
+        return `const $$evaluatedValues = [${newResult}];`;
+    }
+    return `const $$evaluatedValues = ${JSON.stringify(values || [])};`;
+}
+function evaluatedResult() {
+    return (renderer)=>{
+        renderer.evaluatedResults = new Map();
+        renderer.setEvaluatedResult = (fileName, index, value)=>{
+            if (!renderer.evaluatedResults.has(fileName)) {
+                renderer.evaluatedResults.set(fileName, []);
+            }
+            renderer.evaluatedResults.get(fileName)[index] = value;
+        };
+        renderer.getResult = (filePath, isServer)=>{
+            const result = createResult(renderer, filePath, isServer || false);
+            return {
+                result,
+                get css () {
+                    return renderer.renderToString?.(filePath) || "";
+                }
+            };
+        };
+        return renderer;
+    };
+}
+
+function isMediaQuery(rule) {
+    return rule.startsWith('@media');
+}
+function isSupportsQuery(rule) {
+    return rule.startsWith('@supports');
+}
+function isPseudoSelector(rule) {
+    return rule.startsWith(':');
+}
+function wrapWith(atRule, query, content) {
+    return query.length > 0 ? `${atRule} ${query} {${content}}` : content;
+}
+function createCssRule(selector, properties) {
+    return `${selector}{${properties.map((rule)=>`${cssifyProperty(rule.property)}: ${rule.value};`).join('')}}`;
+}
+function generateCombinedMediaQuery(currentMediaQuery, nestedMediaQuery) {
+    if (currentMediaQuery.length === 0) {
+        return nestedMediaQuery;
+    }
+    return `${currentMediaQuery} and ${nestedMediaQuery}`;
+}
+function cssifyProperty(property) {
+    return property.replace(/([a-zA-Z])([A-Z])/g, '$1-$2').toLowerCase();
+}
+function isObject(value) {
+    return typeof value === 'object' && !Array.isArray(value);
+}
+function collectAndGroupRules(cssObj, currentSupportsQuery = '', currentMediaQuery = '', currentPseudoSelector = '', groupedRules = {}) {
+    for (const [property, value] of Object.entries(cssObj)){
+        if (!isObject(value)) {
+            if (!groupedRules[currentSupportsQuery]) {
+                groupedRules[currentSupportsQuery] = {};
+            }
+            const supportsGroup = groupedRules[currentSupportsQuery];
+            if (!supportsGroup[currentMediaQuery]) {
+                supportsGroup[currentMediaQuery] = {};
+            }
+            const mediaGroup = supportsGroup[currentMediaQuery];
+            if (!mediaGroup[currentPseudoSelector]) {
+                mediaGroup[currentPseudoSelector] = [];
+            }
+            mediaGroup[currentPseudoSelector].push({
+                property,
+                value
+            });
+            continue;
+        }
+        if (isMediaQuery(property)) {
+            collectAndGroupRules(value, currentSupportsQuery, generateCombinedMediaQuery(currentMediaQuery, property.slice(6).trim()), currentPseudoSelector, groupedRules);
+            continue;
+        }
+        if (isSupportsQuery(property)) {
+            collectAndGroupRules(value, generateCombinedMediaQuery(currentSupportsQuery, property.slice(9).trim()), currentMediaQuery, currentPseudoSelector, groupedRules);
+            continue;
+        }
+        if (isPseudoSelector(property)) {
+            collectAndGroupRules(value, currentSupportsQuery, currentMediaQuery, currentPseudoSelector + property, groupedRules);
+        }
+    }
+    return groupedRules;
+}
+function serializeCss(selector, cssObj) {
+    const processPseudoSelectors = (pseudoSelectors)=>Object.entries(pseudoSelectors).map(([pseudo, properties])=>createCssRule(`${selector}${pseudo}`, properties)).join('');
+    const processMediaQueries = (mediaQueries)=>Object.entries(mediaQueries).map(([media, pseudoSelectors])=>wrapWith('@media', media, processPseudoSelectors(pseudoSelectors))).join('');
+    const rules = collectAndGroupRules(cssObj);
+    return Object.entries(rules).map(([supports, mediaQueries])=>wrapWith('@supports', supports, processMediaQueries(mediaQueries))).join('');
+}
+function nestedStatic() {
+    // Fela doesn't handle nested static styles correctly. This is a workaround for now.
+    // https://github.com/robinweser/fela/issues/876
+    // https://github.com/robinweser/fela/issues/465#issuecomment-594396150
+    // https://github.com/robinweser/fela/issues/863
+    return (renderer)=>{
+        const { renderStatic  } = renderer;
+        renderer.renderStatic = (staticStyle, selector)=>{
+            return renderStatic(serializeCss(selector, staticStyle), undefined);
+        };
+        return renderer;
+    };
+}
+
+function renderToString() {
+    return (renderer)=>{
+        renderer.renderToString = (fileName)=>{
+            if (!renderer.getScopedCache || !renderer.accessedKeys) {
+                return renderToString$1(renderer);
+            }
+            if (fileName) {
+                return renderToString$1({
+                    ...renderer,
+                    cache: renderer.getScopedCache(fileName)
+                });
+            }
+            const newCache = {};
+            for (const keys of renderer.accessedKeys.values()){
+                for (const key of keys){
+                    const item = renderer.cache[key];
+                    if (!item) {
+                        continue;
+                    }
+                    newCache[key] = item;
+                }
+            }
+            return renderToString$1({
+                ...renderer,
+                cache: newCache
+            });
+        };
+        return renderer;
+    };
+}
+
+function scopedCache() {
+    return (renderer)=>{
+        let currentFileName;
+        const ensureCache = ()=>{
+            if (isProxy(renderer.cache)) {
+                return;
+            }
+            renderer.cache = new Proxy(renderer.cache, {
+                getOwnPropertyDescriptor (target, key) {
+                    const result = Reflect.getOwnPropertyDescriptor(target, key);
+                    const { accessedKeys  } = renderer;
+                    if (!currentFileName) {
+                        return result;
+                    }
+                    if (!accessedKeys.has(currentFileName)) {
+                        accessedKeys.set(currentFileName, new Set());
+                    }
+                    accessedKeys.get(currentFileName)?.add(key);
+                    return result;
+                }
+            });
+        };
+        renderer.setFilePath = (filePath)=>{
+            currentFileName = filePath;
+            // After we've set the file path, we need to ensure that the cache is a proxy,
+            // and set up to record accessed keys.
+            // Without a filePath, the proxy on the cache doesn't make sense, so this is a good place to do it.
+            ensureCache();
+        };
+        renderer.accessedKeys = new Map();
+        renderer.clearAccessedKeys = (filePath)=>{
+            renderer.accessedKeys.get(filePath)?.clear();
+        };
+        renderer.getScopedCache = (filePath)=>{
+            const { accessedKeys  } = renderer;
+            const newCache = {};
+            if (accessedKeys.has(filePath)) {
+                const keys = accessedKeys.get(filePath);
+                for (const key of keys){
+                    const item = renderer.cache[key];
+                    if (!item) {
+                        continue;
+                    }
+                    newCache[key] = item;
+                }
+            }
+            return newCache;
+        };
+        renderer.classPropertyList = new Map();
+        renderer.subscribe((message)=>{
+            if (message.type === 'RULE') {
+                const { declaration , className  } = message;
+                const [property] = declaration.split(':');
+                if (!property) {
+                    return;
+                }
+                const { classPropertyList  } = renderer;
+                if (!classPropertyList.has(className)) {
+                    classPropertyList.set(className, new Set());
+                }
+                classPropertyList.get(className)?.add(property);
+            }
+        });
+        return renderer;
+    };
+}
+
+function serializedCache(keys = []) {
+    return (renderer)=>{
+        renderer.serialize = ()=>{
+            const obj = {};
+            for (const key of keys){
+                const value = renderer[key];
+                if (isProxy(value)) {
+                    obj[key] = Object.assign({}, value);
+                } else {
+                    obj[key] = value;
+                }
+            }
+            return v8.serialize(obj).toString('base64');
+        };
+        renderer.deserialize = (serialized)=>{
+            if (!serialized) {
+                return;
+            }
+            const data = v8.deserialize(Buffer.from(serialized, 'base64'));
+            for (const [key, value] of Object.entries(data)){
+                renderer[key] = value;
+            }
+        };
+        return renderer;
+    };
+}
+
+function createRenderer() {
+    return createRenderer$1({
+        enhancers: [
+            className([
+                'ad'
+            ]),
+            scopedCache(),
+            serializedCache([
+                'cache',
+                'classPropertyList',
+                'accessedKeys',
+                'uniqueRuleIdentifier',
+                'uniqueKeyframeIdentifier'
+            ]),
+            evaluatedResult(),
+            renderToString(),
+            nestedStatic()
+        ]
+    });
+}
+
+export { createRenderer };

package/evaluateAndProcess.d.ts

@@ -0,0 +1,14 @@
+import { Renderer } from './createRenderer.js';
+import 'fela';
+import '@navita/types';
+
+interface Params {
+    source: string;
+    key?: string;
+    filepath: string;
+    isServer?: boolean;
+    renderer: Renderer;
+}
+declare function evaluateAndProcess({ source, renderer, filepath }: Params): Promise<void>;
+
+export { evaluateAndProcess };

package/evaluateAndProcess.js

@@ -0,0 +1,66 @@
+'use strict';
+
+var node_path = require('node:path');
+var vm = require('node:vm');
+
+function _interopNamespaceDefault(e) {
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var vm__namespace = /*#__PURE__*/_interopNamespaceDefault(vm);
+
+async function evaluateAndProcess({ source , renderer , filepath  }) {
+    /**
+   * This needs to be loaded via require. The resolving logic in vm.Script is using
+   * cjs to populate the renderer. We need to point to the same instance.
+   */ require('./').setAdapter(renderer);
+    const requireLike = (request)=>{
+        const resolved = (()=>{
+            try {
+                return require.resolve(request, {
+                    paths: [
+                        node_path.dirname(filepath),
+                        // This allows us to use modules in this package.
+                        __dirname
+                    ]
+                });
+            } catch (e) {
+                return undefined;
+            }
+        })();
+        // If we couldn't find the module, try with the request,
+        // so we'll get correct error messages.
+        return require(resolved || request);
+    };
+    const context = {};
+    const globalProperties = Object.getOwnPropertyNames(global);
+    globalProperties.forEach((key)=>{
+        context[key] = global[key];
+    });
+    const vmGlobals = new vm__namespace.Script('Object.getOwnPropertyNames(globalThis)').runInNewContext();
+    Object.keys(vmGlobals).forEach((key)=>{
+        context[key] = vmGlobals[key];
+    });
+    context['require'] = requireLike;
+    context['console'] = console;
+    const script = new vm__namespace.Script(source, {
+        filename: filepath
+    });
+    script.runInContext(vm__namespace.createContext(context));
+    renderer.setFilePath(undefined);
+}
+
+exports.evaluateAndProcess = evaluateAndProcess;

package/evaluateAndProcess.mjs

@@ -0,0 +1,51 @@
+import { fileURLToPath as fileURLToPath$1 } from 'url';
+const __filename = fileURLToPath$1(import.meta.url);
+import { dirname as dirname$1 } from 'path';
+const __dirname = dirname$1(__filename);
+import { createRequire as createRequire$1 } from 'module';
+const require = createRequire$1(import.meta.url);
+import { dirname } from 'node:path';
+import * as vm from 'node:vm';
+
+async function evaluateAndProcess({ source , renderer , filepath  }) {
+    /**
+   * This needs to be loaded via require. The resolving logic in vm.Script is using
+   * cjs to populate the renderer. We need to point to the same instance.
+   */ require('./').setAdapter(renderer);
+    const requireLike = (request)=>{
+        const resolved = (()=>{
+            try {
+                return require.resolve(request, {
+                    paths: [
+                        dirname(filepath),
+                        // This allows us to use modules in this package.
+                        __dirname
+                    ]
+                });
+            } catch (e) {
+                return undefined;
+            }
+        })();
+        // If we couldn't find the module, try with the request,
+        // so we'll get correct error messages.
+        return require(resolved || request);
+    };
+    const context = {};
+    const globalProperties = Object.getOwnPropertyNames(global);
+    globalProperties.forEach((key)=>{
+        context[key] = global[key];
+    });
+    const vmGlobals = new vm.Script('Object.getOwnPropertyNames(globalThis)').runInNewContext();
+    Object.keys(vmGlobals).forEach((key)=>{
+        context[key] = vmGlobals[key];
+    });
+    context['require'] = requireLike;
+    context['console'] = console;
+    const script = new vm.Script(source, {
+        filename: filepath
+    });
+    script.runInContext(vm.createContext(context));
+    renderer.setFilePath(undefined);
+}
+
+export { evaluateAndProcess };

package/index.d.ts

@@ -0,0 +1,23 @@
+import { StyleRule, GlobalStyleRule, CSSKeyframes } from '@navita/types';
+import { Renderer } from './createRenderer.js';
+import 'fela';
+
+type Adapter = {
+    generateIdentifier: typeof generateIdentifier;
+    setCss: typeof setCss;
+    setStaticCss: typeof setStaticCss;
+    setKeyFrame: typeof setKeyFrame;
+    collectResult?: typeof collectResult;
+};
+declare const setAdapter: (renderer: Renderer) => void;
+declare function generateIdentifier(value: unknown): string;
+declare function setCss(css: StyleRule): string;
+declare function setStaticCss(selector: string, css: GlobalStyleRule): void;
+declare function setKeyFrame(keyframe: CSSKeyframes): string;
+declare function collectResult<T>(input: {
+    filePath: string;
+    index: number;
+    result: () => T;
+}): T;
+
+export { Adapter, collectResult, generateIdentifier, setAdapter, setCss, setKeyFrame, setStaticCss };

package/index.js

@@ -0,0 +1,55 @@
+'use strict';
+
+var hash = require('@emotion/hash');
+
+let adapter = undefined;
+const setAdapter = (renderer)=>{
+    adapter = {
+        generateIdentifier: (value)=>{
+            const identifier = hash(JSON.stringify(value));
+            return identifier.match(/^[0-9]/) ? "_".concat(identifier) : identifier;
+        },
+        setStaticCss: (selector, css)=>{
+            return renderer.renderStatic(css, selector);
+        },
+        setCss: (css)=>{
+            return renderer.renderRule(()=>css);
+        },
+        setKeyFrame (keyframe) {
+            return renderer.renderKeyframe(()=>keyframe, JSON.stringify(keyframe));
+        },
+        collectResult ({ filePath , index , result  }) {
+            // If it's the first index, we can clear the accessed keys.
+            if (index === 0) {
+                renderer.clearAccessedKeys(filePath);
+            }
+            // Filepath is used to scope the cache.
+            renderer.setFilePath(filePath);
+            const collected = result();
+            renderer.setEvaluatedResult(filePath, index, collected);
+            return collected;
+        }
+    };
+};
+function generateIdentifier(value) {
+    return adapter?.generateIdentifier(value);
+}
+function setCss(css) {
+    return adapter?.setCss(css);
+}
+function setStaticCss(selector, css) {
+    return adapter?.setStaticCss(selector, css);
+}
+function setKeyFrame(keyframe) {
+    return adapter?.setKeyFrame(keyframe);
+}
+function collectResult(input) {
+    return adapter?.collectResult?.(input);
+}
+
+exports.collectResult = collectResult;
+exports.generateIdentifier = generateIdentifier;
+exports.setAdapter = setAdapter;
+exports.setCss = setCss;
+exports.setKeyFrame = setKeyFrame;
+exports.setStaticCss = setStaticCss;

package/index.mjs

@@ -0,0 +1,48 @@
+import hash from '@emotion/hash';
+
+let adapter = undefined;
+const setAdapter = (renderer)=>{
+    adapter = {
+        generateIdentifier: (value)=>{
+            const identifier = hash(JSON.stringify(value));
+            return identifier.match(/^[0-9]/) ? "_".concat(identifier) : identifier;
+        },
+        setStaticCss: (selector, css)=>{
+            return renderer.renderStatic(css, selector);
+        },
+        setCss: (css)=>{
+            return renderer.renderRule(()=>css);
+        },
+        setKeyFrame (keyframe) {
+            return renderer.renderKeyframe(()=>keyframe, JSON.stringify(keyframe));
+        },
+        collectResult ({ filePath , index , result  }) {
+            // If it's the first index, we can clear the accessed keys.
+            if (index === 0) {
+                renderer.clearAccessedKeys(filePath);
+            }
+            // Filepath is used to scope the cache.
+            renderer.setFilePath(filePath);
+            const collected = result();
+            renderer.setEvaluatedResult(filePath, index, collected);
+            return collected;
+        }
+    };
+};
+function generateIdentifier(value) {
+    return adapter?.generateIdentifier(value);
+}
+function setCss(css) {
+    return adapter?.setCss(css);
+}
+function setStaticCss(selector, css) {
+    return adapter?.setStaticCss(selector, css);
+}
+function setKeyFrame(keyframe) {
+    return adapter?.setKeyFrame(keyframe);
+}
+function collectResult(input) {
+    return adapter?.collectResult?.(input);
+}
+
+export { collectResult, generateIdentifier, setAdapter, setCss, setKeyFrame, setStaticCss };

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@navita/core",
+  "version": "0.0.0",
+  "license": "MIT",
+  "private": false,
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "import": "./index.mjs",
+      "require": "./index.js",
+      "types": "./index.d.ts"
+    },
+    "./*": {
+      "import": "./*.mjs",
+      "require": "./*.js",
+      "types": "./*.d.ts"
+    },
+    "./package.json": "./package.json"
+  },
+  "dependencies": {
+    "@navita/types": "*",
+    "@emotion/hash": "^0.9.0",
+    "fela": "12.2.1",
+    "fela-tools": "12.2.1",
+    "fela-utils": "12.2.1"
+  }
+}