@craft-ts/core 0.7.0-beta.13

package/src/lib/browser-boundaries.js

@@ -0,0 +1,550 @@
+import { abstract, craftService, ɵHOST_TAG_LIST, ɵTRACK_TAGS_LIST, } from './craft-service';
+import { CORRELATION_ID_SERVICE, getCurrentStartCorrelationId, } from './correlation-id';
+import { SERVICE_YIELD_REQUEST_MARKER } from './craft-generator-runtime';
+import { CRAFT_PLATFORM } from './craft-platform';
+import { getCurrentCraftInjector } from './host/craft-injector';
+/** Storage backend selected by the application through DI. */
+const storageService = craftService({ name: 'StorageService', providedIn: 'abstract' }, abstract());
+export const StorageService = storageService.StorageService;
+export const StorageServiceRequirement = storageService.StorageServiceRequirement;
+export const provideStorageService = storageService.provideStorageService;
+function createBoundaryCall(serviceHelper) {
+    return function (key) {
+        return function* (...args) {
+            const exposed = (yield* serviceHelper(undefined, (service) => ({
+                method: service[key],
+            })));
+            return exposed.method(...args);
+        };
+    };
+}
+const CONSOLE_INTERNAL_FRAME_PATTERNS = [
+    'runCraftGenerator',
+    'executeGeneratorCompatibleFactory',
+    'runInInjectionContext',
+    'createConsoleCall',
+    'Object.log',
+    'Object.info',
+    'Object.debug',
+    'Object.warn',
+    'Object.error',
+    'Object.trace',
+];
+function parseConsoleStackTrace(stack) {
+    if (!stack)
+        return '';
+    const lines = stack.split('\n');
+    const filtered = lines
+        .slice(1) // remove the "Error" header line
+        .filter((line) => !CONSOLE_INTERNAL_FRAME_PATTERNS.some((pattern) => line.includes(pattern)));
+    return filtered.join('\n');
+}
+function getConsoleBrowserInfo() {
+    const nav = globalThis.navigator;
+    if (!nav)
+        return undefined;
+    const scr = globalThis.screen;
+    return {
+        userAgent: nav.userAgent,
+        language: nav.language,
+        languages: nav.languages,
+        onLine: nav.onLine,
+        platform: 'platform' in nav ? nav.platform : undefined,
+        screen: scr ? { width: scr.width, height: scr.height } : undefined,
+    };
+}
+function createConsoleCall(key) {
+    return function* (...args) {
+        const consoleService = yield* ConsoleService();
+        const { from, tags, correlation: correlationMeta, } = (yield {
+            [SERVICE_YIELD_REQUEST_MARKER]: true,
+            providedIn: 'function',
+            resolve: (injector) => ({
+                from: injector.get(ɵHOST_TAG_LIST),
+                tags: injector.get(ɵTRACK_TAGS_LIST),
+                correlation: {
+                    lastCorrelationId: injector.get(CORRELATION_ID_SERVICE, null)?.lastCorrelationId() ??
+                        null,
+                    mayCorrelatedIds: injector.get(CORRELATION_ID_SERVICE, null)?.mayCorrelatedIds() ??
+                        [],
+                    startCorrelationId: getCurrentStartCorrelationId(),
+                },
+            }),
+        });
+        const metadata = {
+            from,
+            tags,
+            trace: parseConsoleStackTrace(new Error().stack),
+            correlationId: correlationMeta,
+            timestamp: new Date().toUTCString(),
+            route: globalThis.window?.location?.href ?? '',
+        };
+        if (key === 'error') {
+            metadata.browser = getConsoleBrowserInfo();
+        }
+        return consoleService[key](...args, metadata);
+    };
+}
+function requireBrowserValue(value, name) {
+    if (value === undefined || value === null) {
+        throw new Error(`Browser boundary "${name}" is not available outside a browser environment.`);
+    }
+    return value;
+}
+function getBrowserWindow() {
+    return requireBrowserValue(getActivePlatform()?.window ?? globalThis.window, 'window');
+}
+function getBrowserDocument() {
+    return requireBrowserValue(getActivePlatform()?.document ?? globalThis.document, 'document');
+}
+function getActivePlatform() {
+    try {
+        return getCurrentCraftInjector().get(CRAFT_PLATFORM, null) ?? undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** @internal Angular TitleStrategy writes the document title through the same boundary as `BrowserDocument.setTitle`. */
+export function ɵapplyBrowserDocumentTitle(value) {
+    getBrowserDocument().title = value;
+}
+function createInMemoryStorage() {
+    const values = new Map();
+    return {
+        clear: () => {
+            values.clear();
+        },
+        getItem: (key) => values.get(key) ?? null,
+        key: (index) => Array.from(values.keys())[index] ?? null,
+        removeItem: (key) => {
+            values.delete(key);
+        },
+        setItem: (key, value) => {
+            values.set(key, value);
+        },
+        get length() {
+            return values.size;
+        },
+    };
+}
+function getBrowserStorage(name) {
+    const platform = getActivePlatform();
+    if (platform)
+        return platform[name];
+    const browserWindow = getBrowserWindow();
+    const candidate = browserWindow[name];
+    if (candidate &&
+        typeof candidate.getItem === 'function' &&
+        typeof candidate.setItem === 'function' &&
+        typeof candidate.removeItem === 'function' &&
+        typeof candidate.clear === 'function' &&
+        typeof candidate.key === 'function' &&
+        typeof candidate.length === 'number') {
+        return candidate;
+    }
+    const fallbackKey = Symbol.for(`craft.browser-boundary.${name}`);
+    if (!(fallbackKey in browserWindow)) {
+        Object.defineProperty(browserWindow, fallbackKey, {
+            value: createInMemoryStorage(),
+            enumerable: false,
+            configurable: false,
+            writable: false,
+        });
+    }
+    return browserWindow[fallbackKey];
+}
+function getBrowserLocalStorage() {
+    return getBrowserStorage('localStorage');
+}
+function getBrowserSessionStorage() {
+    return getBrowserStorage('sessionStorage');
+}
+function getBrowserLocation() {
+    return requireBrowserValue(getBrowserWindow().location, 'location');
+}
+function getBrowserHistory() {
+    return requireBrowserValue(getBrowserWindow().history, 'history');
+}
+function getBrowserNavigator() {
+    return requireBrowserValue(getBrowserWindow().navigator, 'navigator');
+}
+function getBrowserPerformance() {
+    return requireBrowserValue(getBrowserWindow().performance, 'performance');
+}
+function getBrowserCrypto() {
+    return requireBrowserValue(getBrowserWindow().crypto, 'crypto');
+}
+function decodeCookieComponent(value) {
+    try {
+        return decodeURIComponent(value);
+    }
+    catch {
+        return value;
+    }
+}
+function readCookieEntries() {
+    const rawCookie = getBrowserDocument().cookie;
+    if (!rawCookie) {
+        return [];
+    }
+    return rawCookie
+        .split(';')
+        .map((part) => part.trim())
+        .filter(Boolean)
+        .map((part) => {
+        const separatorIndex = part.indexOf('=');
+        const rawName = separatorIndex === -1 ? part : part.slice(0, separatorIndex);
+        const rawValue = separatorIndex === -1 ? '' : part.slice(separatorIndex + 1);
+        return [
+            decodeCookieComponent(rawName),
+            decodeCookieComponent(rawValue),
+        ];
+    });
+}
+function buildCookieMap() {
+    return Object.fromEntries(readCookieEntries());
+}
+function formatCookieSameSite(value) {
+    return value.charAt(0).toUpperCase() + value.slice(1).toLowerCase();
+}
+function writeCookie(name, value, options) {
+    const segments = [`${encodeURIComponent(name)}=${encodeURIComponent(value)}`];
+    if (options?.domain) {
+        segments.push(`Domain=${options.domain}`);
+    }
+    if (options?.expires) {
+        segments.push(`Expires=${options.expires instanceof Date
+            ? options.expires.toUTCString()
+            : options.expires}`);
+    }
+    if (options?.maxAge !== undefined) {
+        segments.push(`Max-Age=${options.maxAge}`);
+    }
+    if (options?.path) {
+        segments.push(`Path=${options.path}`);
+    }
+    if (options?.sameSite) {
+        segments.push(`SameSite=${formatCookieSameSite(options.sameSite)}`);
+    }
+    if (options?.secure) {
+        segments.push('Secure');
+    }
+    if (options?.partitioned) {
+        segments.push('Partitioned');
+    }
+    getBrowserDocument().cookie = segments.join('; ');
+}
+function removeCookie(name, options) {
+    writeCookie(name, '', {
+        ...options,
+        expires: new Date(0),
+        maxAge: 0,
+        path: options?.path ?? '/',
+    });
+}
+const consoleService = craftService({
+    name: 'ConsoleService',
+    providedIn: 'global',
+    browserBoundary: true,
+}, () => ({
+    debug: (...data) => globalThis.console.debug(...data),
+    info: (...data) => globalThis.console.info(...data),
+    log: (...data) => globalThis.console.log(...data),
+    warn: (...data) => globalThis.console.warn(...data),
+    error: (...data) => globalThis.console.error(...data),
+    trace: (...data) => globalThis.console.trace(...data),
+    group: (...label) => globalThis.console.group(...label),
+    groupCollapsed: (...label) => globalThis.console.groupCollapsed(...label),
+    groupEnd: () => globalThis.console.groupEnd(),
+    time: (label) => globalThis.console.time(label),
+    timeEnd: (label) => globalThis.console.timeEnd(label),
+}));
+export const ConsoleService = consoleService.ConsoleService;
+export const CONSOLE_SERVICE_META_DATA = consoleService.CONSOLE_SERVICE_META_DATA;
+const localStorageService = craftService({
+    name: 'LocalStorageService',
+    providedIn: 'global',
+    browserBoundary: true,
+}, () => ({
+    getItem: (key) => getBrowserLocalStorage().getItem(key),
+    setItem: (key, value) => getBrowserLocalStorage().setItem(key, value),
+    removeItem: (key) => getBrowserLocalStorage().removeItem(key),
+    clear: () => getBrowserLocalStorage().clear(),
+    key: (index) => getBrowserLocalStorage().key(index),
+    length: () => getBrowserLocalStorage().length,
+}));
+export const LocalStorageService = localStorageService.LocalStorageService;
+export const LOCAL_STORAGE_SERVICE_META_DATA = localStorageService.LOCAL_STORAGE_SERVICE_META_DATA;
+const sessionStorageService = craftService({
+    name: 'SessionStorageService',
+    providedIn: 'global',
+    browserBoundary: true,
+}, () => ({
+    getItem: (key) => getBrowserSessionStorage().getItem(key),
+    setItem: (key, value) => getBrowserSessionStorage().setItem(key, value),
+    removeItem: (key) => getBrowserSessionStorage().removeItem(key),
+    clear: () => getBrowserSessionStorage().clear(),
+    key: (index) => getBrowserSessionStorage().key(index),
+    length: () => getBrowserSessionStorage().length,
+}));
+export const SessionStorageService = sessionStorageService.SessionStorageService;
+export const SESSION_STORAGE_SERVICE_META_DATA = sessionStorageService.SESSION_STORAGE_SERVICE_META_DATA;
+const cookiesService = craftService({
+    name: 'CookiesService',
+    providedIn: 'global',
+    browserBoundary: true,
+}, () => ({
+    get: (name) => buildCookieMap()[name],
+    getAll: () => buildCookieMap(),
+    set: (name, value, options) => writeCookie(name, value, options),
+    remove: (name, options) => removeCookie(name, options),
+    has: (name) => Object.prototype.hasOwnProperty.call(buildCookieMap(), name),
+}));
+export const CookiesService = cookiesService.CookiesService;
+export const COOKIES_SERVICE_META_DATA = cookiesService.COOKIES_SERVICE_META_DATA;
+const browserLocationService = craftService({
+    name: 'BrowserLocationService',
+    providedIn: 'global',
+    browserBoundary: true,
+}, () => ({
+    href: () => getBrowserLocation().href,
+    origin: () => getBrowserLocation().origin,
+    protocol: () => getBrowserLocation().protocol,
+    host: () => getBrowserLocation().host,
+    hostname: () => getBrowserLocation().hostname,
+    port: () => getBrowserLocation().port,
+    pathname: () => getBrowserLocation().pathname,
+    search: () => getBrowserLocation().search,
+    hash: () => getBrowserLocation().hash,
+    assign: (url) => getBrowserLocation().assign(url),
+    replace: (url) => getBrowserLocation().replace(url),
+    reload: () => getBrowserLocation().reload(),
+}));
+export const BrowserLocationService = browserLocationService.BrowserLocationService;
+export const BROWSER_LOCATION_SERVICE_META_DATA = browserLocationService.BROWSER_LOCATION_SERVICE_META_DATA;
+const browserHistoryService = craftService({
+    name: 'BrowserHistoryService',
+    providedIn: 'global',
+    browserBoundary: true,
+}, () => ({
+    length: () => getBrowserHistory().length,
+    state: () => getBrowserHistory().state,
+    back: () => getBrowserHistory().back(),
+    forward: () => getBrowserHistory().forward(),
+    go: (delta) => getBrowserHistory().go(delta),
+    pushState: (data, unused, url) => getBrowserHistory().pushState(data, unused, url),
+    replaceState: (data, unused, url) => getBrowserHistory().replaceState(data, unused, url),
+}));
+export const BrowserHistoryService = browserHistoryService.BrowserHistoryService;
+export const BROWSER_HISTORY_SERVICE_META_DATA = browserHistoryService.BROWSER_HISTORY_SERVICE_META_DATA;
+const browserNavigatorService = craftService({
+    name: 'BrowserNavigatorService',
+    providedIn: 'global',
+    browserBoundary: true,
+}, () => ({
+    userAgent: () => getBrowserNavigator().userAgent,
+    language: () => getBrowserNavigator().language,
+    languages: () => getBrowserNavigator().languages,
+    onLine: () => getBrowserNavigator().onLine,
+    cookieEnabled: () => getBrowserNavigator().cookieEnabled,
+    sendBeacon: (url, data) => getBrowserNavigator().sendBeacon(url, data),
+    share: (data) => getBrowserNavigator().share(data),
+}));
+export const BrowserNavigatorService = browserNavigatorService.BrowserNavigatorService;
+export const BROWSER_NAVIGATOR_SERVICE_META_DATA = browserNavigatorService.BROWSER_NAVIGATOR_SERVICE_META_DATA;
+const browserPerformanceService = craftService({
+    name: 'BrowserPerformanceService',
+    providedIn: 'global',
+    browserBoundary: true,
+}, () => ({
+    now: () => getBrowserPerformance().now(),
+    mark: (name, options) => getBrowserPerformance().mark(name, options),
+    measure: (measureName, startOrMeasureOptions, endMark) => {
+        if (endMark !== undefined) {
+            return getBrowserPerformance().measure(measureName, startOrMeasureOptions, endMark);
+        }
+        if (startOrMeasureOptions !== undefined) {
+            return getBrowserPerformance().measure(measureName, startOrMeasureOptions);
+        }
+        return getBrowserPerformance().measure(measureName);
+    },
+    clearMarks: (markName) => getBrowserPerformance().clearMarks(markName),
+    clearMeasures: (measureName) => getBrowserPerformance().clearMeasures(measureName),
+}));
+export const BrowserPerformanceService = browserPerformanceService.BrowserPerformanceService;
+export const BROWSER_PERFORMANCE_SERVICE_META_DATA = browserPerformanceService.BROWSER_PERFORMANCE_SERVICE_META_DATA;
+const browserCryptoService = craftService({
+    name: 'BrowserCryptoService',
+    providedIn: 'global',
+    browserBoundary: true,
+}, () => ({
+    randomUUID: () => getBrowserCrypto().randomUUID(),
+    getRandomValues: (typedArray) => getBrowserCrypto().getRandomValues(typedArray),
+    digest: (algorithm, data) => getBrowserCrypto().subtle.digest(algorithm, data),
+}));
+export const BrowserCryptoService = browserCryptoService.BrowserCryptoService;
+export const BROWSER_CRYPTO_SERVICE_META_DATA = browserCryptoService.BROWSER_CRYPTO_SERVICE_META_DATA;
+const browserDocumentService = craftService({
+    name: 'BrowserDocumentService',
+    providedIn: 'global',
+    browserBoundary: true,
+}, () => ({
+    title: () => getBrowserDocument().title,
+    setTitle: (value) => {
+        ɵapplyBrowserDocumentTitle(value);
+    },
+    lang: () => getBrowserDocument().documentElement.lang,
+    setLang: (value) => {
+        getBrowserDocument().documentElement.lang = value;
+    },
+    dir: () => (getBrowserDocument().documentElement.getAttribute('dir') ?? ''),
+    setDir: (value) => {
+        const el = getBrowserDocument().documentElement;
+        if (value) {
+            el.setAttribute('dir', value);
+        }
+        else {
+            el.removeAttribute('dir');
+        }
+    },
+    visibilityState: () => getBrowserDocument().visibilityState,
+    hasFocus: () => getBrowserDocument().hasFocus(),
+}));
+export const BrowserDocumentService = browserDocumentService.BrowserDocumentService;
+export const BROWSER_DOCUMENT_SERVICE_META_DATA = browserDocumentService.BROWSER_DOCUMENT_SERVICE_META_DATA;
+const browserWindowService = craftService({
+    name: 'BrowserWindowService',
+    providedIn: 'global',
+    browserBoundary: true,
+}, () => ({
+    innerWidth: () => getBrowserWindow().innerWidth,
+    innerHeight: () => getBrowserWindow().innerHeight,
+    scrollX: () => getBrowserWindow().scrollX,
+    scrollY: () => getBrowserWindow().scrollY,
+    scrollTo: (...args) => {
+        if (args.length === 1) {
+            getBrowserWindow().scrollTo(args[0]);
+            return;
+        }
+        getBrowserWindow().scrollTo(args[0], args[1]);
+    },
+    alert: (message) => getBrowserWindow().alert(message),
+    confirm: (message) => getBrowserWindow().confirm(message),
+}));
+export const BrowserWindowService = browserWindowService.BrowserWindowService;
+export const BROWSER_WINDOW_SERVICE_META_DATA = browserWindowService.BROWSER_WINDOW_SERVICE_META_DATA;
+const callRawConsole = createBoundaryCall(ConsoleService);
+const callLocalStorage = createBoundaryCall(LocalStorageService);
+const callSessionStorage = createBoundaryCall(SessionStorageService);
+const callCookies = createBoundaryCall(CookiesService);
+const callBrowserLocation = createBoundaryCall(BrowserLocationService);
+const callBrowserHistory = createBoundaryCall(BrowserHistoryService);
+const callBrowserNavigator = createBoundaryCall(BrowserNavigatorService);
+const callBrowserPerformance = createBoundaryCall(BrowserPerformanceService);
+const callBrowserCrypto = createBoundaryCall(BrowserCryptoService);
+const callBrowserDocument = createBoundaryCall(BrowserDocumentService);
+const callBrowserWindow = createBoundaryCall(BrowserWindowService);
+export const Console = {
+    debug: createConsoleCall('debug'),
+    info: createConsoleCall('info'),
+    log: createConsoleCall('log'),
+    warn: createConsoleCall('warn'),
+    error: createConsoleCall('error'),
+    trace: callRawConsole('trace'),
+    group: callRawConsole('group'),
+    groupCollapsed: callRawConsole('groupCollapsed'),
+    groupEnd: callRawConsole('groupEnd'),
+    time: callRawConsole('time'),
+    timeEnd: callRawConsole('timeEnd'),
+};
+export const LocalStorage = {
+    getItem: callLocalStorage('getItem'),
+    setItem: callLocalStorage('setItem'),
+    removeItem: callLocalStorage('removeItem'),
+    clear: callLocalStorage('clear'),
+    key: callLocalStorage('key'),
+    length: callLocalStorage('length'),
+};
+export const SessionStorage = {
+    getItem: callSessionStorage('getItem'),
+    setItem: callSessionStorage('setItem'),
+    removeItem: callSessionStorage('removeItem'),
+    clear: callSessionStorage('clear'),
+    key: callSessionStorage('key'),
+    length: callSessionStorage('length'),
+};
+export const Cookies = {
+    get: callCookies('get'),
+    getAll: callCookies('getAll'),
+    set: callCookies('set'),
+    remove: callCookies('remove'),
+    has: callCookies('has'),
+};
+export const BrowserLocation = {
+    href: callBrowserLocation('href'),
+    origin: callBrowserLocation('origin'),
+    protocol: callBrowserLocation('protocol'),
+    host: callBrowserLocation('host'),
+    hostname: callBrowserLocation('hostname'),
+    port: callBrowserLocation('port'),
+    pathname: callBrowserLocation('pathname'),
+    search: callBrowserLocation('search'),
+    hash: callBrowserLocation('hash'),
+    assign: callBrowserLocation('assign'),
+    replace: callBrowserLocation('replace'),
+    reload: callBrowserLocation('reload'),
+};
+export const BrowserHistory = {
+    length: callBrowserHistory('length'),
+    state: callBrowserHistory('state'),
+    back: callBrowserHistory('back'),
+    forward: callBrowserHistory('forward'),
+    go: callBrowserHistory('go'),
+    pushState: callBrowserHistory('pushState'),
+    replaceState: callBrowserHistory('replaceState'),
+};
+export const BrowserNavigator = {
+    userAgent: callBrowserNavigator('userAgent'),
+    language: callBrowserNavigator('language'),
+    languages: callBrowserNavigator('languages'),
+    onLine: callBrowserNavigator('onLine'),
+    cookieEnabled: callBrowserNavigator('cookieEnabled'),
+    sendBeacon: callBrowserNavigator('sendBeacon'),
+    share: callBrowserNavigator('share'),
+};
+export const BrowserPerformance = {
+    now: callBrowserPerformance('now'),
+    mark: callBrowserPerformance('mark'),
+    measure: callBrowserPerformance('measure'),
+    clearMarks: callBrowserPerformance('clearMarks'),
+    clearMeasures: callBrowserPerformance('clearMeasures'),
+};
+export const BrowserCrypto = {
+    randomUUID: callBrowserCrypto('randomUUID'),
+    getRandomValues: function* (typedArray) {
+        const cryptoService = yield* BrowserCryptoService();
+        return cryptoService.getRandomValues(typedArray);
+    },
+    digest: callBrowserCrypto('digest'),
+};
+export const BrowserDocument = {
+    title: callBrowserDocument('title'),
+    setTitle: callBrowserDocument('setTitle'),
+    lang: callBrowserDocument('lang'),
+    setLang: callBrowserDocument('setLang'),
+    dir: callBrowserDocument('dir'),
+    setDir: callBrowserDocument('setDir'),
+    visibilityState: callBrowserDocument('visibilityState'),
+    hasFocus: callBrowserDocument('hasFocus'),
+};
+export const BrowserWindow = {
+    innerWidth: callBrowserWindow('innerWidth'),
+    innerHeight: callBrowserWindow('innerHeight'),
+    scrollX: callBrowserWindow('scrollX'),
+    scrollY: callBrowserWindow('scrollY'),
+    scrollTo: callBrowserWindow('scrollTo'),
+    alert: callBrowserWindow('alert'),
+    confirm: callBrowserWindow('confirm'),
+};
+//# sourceMappingURL=browser-boundaries.js.map