@keycloakify/svelte 0.1.2 → 0.1.4

package/src/bin/tools/SemVer.ts

@@ -0,0 +1,107 @@
+/* eslint-disable @typescript-eslint/no-namespace */
+export type SemVer = {
+  major: number;
+  minor: number;
+  patch: number;
+  rc?: number;
+  parsedFrom: string;
+};
+
+export namespace SemVer {
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  const bumpTypes = ['major', 'minor', 'patch', 'rc', 'no bump'] as const;
+
+  export type BumpType = (typeof bumpTypes)[number];
+
+  export function parse(versionStr: string): SemVer {
+    const match = versionStr.match(/^v?([0-9]+)\.([0-9]+)(?:\.([0-9]+))?(?:-rc.([0-9]+))?$/);
+
+    if (!match) {
+      throw new Error(`${versionStr} is not a valid semantic version`);
+    }
+
+    const semVer: Omit<SemVer, 'parsedFrom'> = {
+      major: parseInt(match[1]),
+      minor: parseInt(match[2]),
+      patch: (() => {
+        const str = match[3];
+
+        return str === undefined ? 0 : parseInt(str);
+      })(),
+      ...(() => {
+        const str = match[4];
+        return str === undefined ? {} : { rc: parseInt(str) };
+      })(),
+    };
+
+    const initialStr = stringify(semVer);
+
+    Object.defineProperty(semVer, 'parsedFrom', {
+      enumerable: true,
+      get: function () {
+        const currentStr = stringify(this);
+
+        if (currentStr !== initialStr) {
+          throw new Error(
+            `SemVer.parsedFrom can't be read anymore, the version have been modified from ${initialStr} to ${currentStr}`,
+          );
+        }
+
+        return versionStr;
+      },
+    });
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return semVer as any;
+  }
+
+  export function stringify(v: Omit<SemVer, 'parsedFrom'>): string {
+    return `${v.major}.${v.minor}.${v.patch}${v.rc === undefined ? '' : `-rc.${v.rc}`}`;
+  }
+
+  /**
+   *
+   * v1  <  v2  => -1
+   * v1 === v2  => 0
+   * v1  >  v2  => 1
+   *
+   */
+  export function compare(v1: SemVer, v2: SemVer): -1 | 0 | 1 {
+    const sign = (diff: number): -1 | 0 | 1 => (diff === 0 ? 0 : diff < 0 ? -1 : 1);
+    const noUndefined = (n: number | undefined) => n ?? Infinity;
+
+    for (const level of ['major', 'minor', 'patch', 'rc'] as const) {
+      if (noUndefined(v1[level]) !== noUndefined(v2[level])) {
+        return sign(noUndefined(v1[level]) - noUndefined(v2[level]));
+      }
+    }
+
+    return 0;
+  }
+
+  /*
+    console.log(compare(parse("3.0.0-rc.3"), parse("3.0.0")) === -1 )
+    console.log(compare(parse("3.0.0-rc.3"), parse("3.0.0-rc.4")) === -1 )
+    console.log(compare(parse("3.0.0-rc.3"), parse("4.0.0")) === -1 )
+    */
+
+  export function bumpType(params: {
+    versionBehind: string | SemVer;
+    versionAhead: string | SemVer;
+  }): BumpType | 'no bump' {
+    const versionAhead = typeof params.versionAhead === 'string' ? parse(params.versionAhead) : params.versionAhead;
+    const versionBehind = typeof params.versionBehind === 'string' ? parse(params.versionBehind) : params.versionBehind;
+
+    if (compare(versionBehind, versionAhead) === 1) {
+      throw new Error(`Version regression ${stringify(versionBehind)} -> ${stringify(versionAhead)}`);
+    }
+
+    for (const level of ['major', 'minor', 'patch', 'rc'] as const) {
+      if (versionBehind[level] !== versionAhead[level]) {
+        return level;
+      }
+    }
+
+    return 'no bump';
+  }
+}

package/src/bin/tools/String.prototype.replaceAll.ts

@@ -0,0 +1,31 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+export function replaceAll(string: string, searchValue: string | RegExp, replaceValue: string): string {
+  if ((string as any).replaceAll !== undefined) {
+    return (string as any).replaceAll(searchValue, replaceValue);
+  }
+
+  // If the searchValue is a string
+  if (typeof searchValue === 'string') {
+    // Escape special characters in the string to be used in a regex
+    const escapedSearchValue = searchValue.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const regex = new RegExp(escapedSearchValue, 'g');
+
+    return string.replace(regex, replaceValue);
+  }
+
+  // If the searchValue is a global RegExp, use it directly
+  if (searchValue instanceof RegExp && searchValue.global) {
+    return string.replace(searchValue, replaceValue);
+  }
+
+  // If the searchValue is a non-global RegExp, throw an error
+  if (searchValue instanceof RegExp) {
+    throw new TypeError('replaceAll must be called with a global RegExp');
+  }
+
+  // Convert searchValue to string if it's not a string or RegExp
+  const searchString = String(searchValue);
+  const regexFromString = new RegExp(searchString.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'g');
+
+  return string.replace(regexFromString, replaceValue);
+}

package/src/bin/tools/crawl.ts

@@ -0,0 +1,32 @@
+import * as fs from 'fs';
+import { join as pathJoin, relative as pathRelative } from 'path';
+
+const crawlRec = (dirPath: string, filePaths: string[]) => {
+  for (const basename of fs.readdirSync(dirPath)) {
+    const fileOrDirPath = pathJoin(dirPath, basename);
+
+    if (fs.lstatSync(fileOrDirPath).isDirectory()) {
+      crawlRec(fileOrDirPath, filePaths);
+
+      continue;
+    }
+
+    filePaths.push(fileOrDirPath);
+  }
+};
+
+/** List all files in a given directory return paths relative to the dir_path */
+export function crawl(params: { dirPath: string; returnedPathsType: 'absolute' | 'relative to dirPath' }): string[] {
+  const { dirPath, returnedPathsType } = params;
+
+  const filePaths: string[] = [];
+
+  crawlRec(dirPath, filePaths);
+
+  switch (returnedPathsType) {
+    case 'absolute':
+      return filePaths;
+    case 'relative to dirPath':
+      return filePaths.map((filePath) => pathRelative(dirPath, filePath));
+  }
+}

package/src/bin/tools/fs.rmSync.ts

@@ -0,0 +1,34 @@
+import * as fs from 'fs';
+import { join as pathJoin } from 'path';
+import { SemVer } from './SemVer';
+
+/**
+ * Polyfill of fs.rmSync(dirPath, { "recursive": true })
+ * For older version of Node
+ */
+export function rmSync(dirPath: string, options: { recursive: true; force?: true }) {
+  if (SemVer.compare(SemVer.parse(process.version), SemVer.parse('14.14.0')) > 0) {
+    fs.rmSync(dirPath, options);
+    return;
+  }
+
+  const { force = true } = options;
+
+  if (force && !fs.existsSync(dirPath)) {
+    return;
+  }
+
+  const removeDir_rec = (dirPath: string) =>
+    fs.readdirSync(dirPath).forEach((basename) => {
+      const fileOrDirPath = pathJoin(dirPath, basename);
+
+      if (fs.lstatSync(fileOrDirPath).isDirectory()) {
+        removeDir_rec(fileOrDirPath);
+        return;
+      } else {
+        fs.unlinkSync(fileOrDirPath);
+      }
+    });
+
+  removeDir_rec(dirPath);
+}

package/src/bin/tools/getThisCodebaseRootDirPath.ts

@@ -0,0 +1,22 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as url from 'url';
+
+const __dirname = path.dirname(url.fileURLToPath(import.meta.url));
+
+function getThisCodebaseRootDirPath_rec(dirPath: string): string {
+  if (!dirPath.includes('/bin') && fs.existsSync(path.join(dirPath, 'package.json'))) {
+    return dirPath;
+  }
+  return getThisCodebaseRootDirPath_rec(path.join(dirPath, '..'));
+}
+
+let result: string | undefined = undefined;
+
+export function getThisCodebaseRootDirPath(): string {
+  if (result !== undefined) {
+    return result;
+  }
+
+  return (result = getThisCodebaseRootDirPath_rec(__dirname));
+}

package/src/bin/tools/kebabCaseToSnakeCase.ts

@@ -0,0 +1,7 @@
+import { capitalize } from 'tsafe/capitalize';
+
+export function kebabCaseToCamelCase(kebabCaseString: string): string {
+  const [first, ...rest] = kebabCaseString.split('-');
+
+  return [first, ...rest.map(capitalize)].join('');
+}

package/src/bin/tools/nodeModulesBinDirPath.ts

@@ -0,0 +1,38 @@
+import { sep as pathSep } from 'path';
+
+let cache: string | undefined = undefined;
+
+export function getNodeModulesBinDirPath() {
+  if (cache !== undefined) {
+    return cache;
+  }
+
+  const binPath = process.argv[1];
+
+  const segments: string[] = ['.bin'];
+
+  let foundNodeModules = false;
+
+  for (const segment of binPath.split(pathSep).reverse()) {
+    skip_segment: {
+      if (foundNodeModules) {
+        break skip_segment;
+      }
+
+      if (segment === 'node_modules') {
+        foundNodeModules = true;
+        break skip_segment;
+      }
+
+      continue;
+    }
+
+    segments.unshift(segment);
+  }
+
+  const nodeModulesBinDirPath = segments.join(pathSep);
+
+  cache = nodeModulesBinDirPath;
+
+  return nodeModulesBinDirPath;
+}

package/src/bin/tools/readThisNpmPackageVersion.ts

@@ -0,0 +1,22 @@
+import * as fs from 'fs';
+import { join as pathJoin } from 'path';
+import { assert } from 'tsafe/assert';
+import { getThisCodebaseRootDirPath } from './getThisCodebaseRootDirPath';
+
+let cache: string | undefined = undefined;
+
+export function readThisNpmPackageVersion(): string {
+  if (cache !== undefined) {
+    return cache;
+  }
+
+  const version = JSON.parse(fs.readFileSync(pathJoin(getThisCodebaseRootDirPath(), 'package.json')).toString('utf8'))[
+    'version'
+  ];
+
+  assert(typeof version === 'string');
+
+  cache = version;
+
+  return version;
+}

package/src/bin/tools/runPrettier.ts

@@ -0,0 +1,118 @@
+import chalk from 'chalk';
+import * as crypto from 'crypto';
+import * as fsPr from 'fs/promises';
+import { join as pathJoin, resolve as pathResolve } from 'path';
+import { assert } from 'tsafe/assert';
+import { id } from 'tsafe/id';
+import { is } from 'tsafe/is';
+import { symToStr } from 'tsafe/symToStr';
+import { getNodeModulesBinDirPath } from './nodeModulesBinDirPath';
+import { readThisNpmPackageVersion } from './readThisNpmPackageVersion';
+
+getIsPrettierAvailable.cache = id<boolean | undefined>(undefined);
+
+export async function getIsPrettierAvailable(): Promise<boolean> {
+  if (getIsPrettierAvailable.cache !== undefined) {
+    return getIsPrettierAvailable.cache;
+  }
+
+  const nodeModulesBinDirPath = getNodeModulesBinDirPath();
+
+  const prettierBinPath = pathJoin(nodeModulesBinDirPath, 'prettier');
+
+  const stats = await fsPr.stat(prettierBinPath).catch(() => undefined);
+
+  const isPrettierAvailable = stats?.isFile() ?? false;
+
+  getIsPrettierAvailable.cache = isPrettierAvailable;
+
+  return isPrettierAvailable;
+}
+
+type PrettierAndConfigHash = {
+  prettier: typeof import('prettier');
+  configHash: string;
+};
+
+getPrettier.cache = id<PrettierAndConfigHash | undefined>(undefined);
+
+export async function getPrettier(): Promise<PrettierAndConfigHash> {
+  assert(getIsPrettierAvailable());
+
+  if (getPrettier.cache !== undefined) {
+    return getPrettier.cache;
+  }
+
+  let prettier = id<typeof import('prettier') | undefined>(undefined);
+
+  import_prettier: {
+    // NOTE: When module is linked we want to make sure we import the correct version
+    // of prettier, that is the one of the project, not the one of this repo.
+    // So we do a sketchy eval to bypass ncc.
+    // We make sure to only do that when linking, otherwise we import properly.
+    if (readThisNpmPackageVersion().startsWith('0.0.0')) {
+      eval(
+        `${symToStr({ prettier })} = require("${pathResolve(pathJoin(getNodeModulesBinDirPath(), '..', 'prettier'))}")`,
+      );
+
+      assert(!is<undefined>(prettier));
+
+      break import_prettier;
+    }
+
+    prettier = await import('prettier');
+  }
+
+  const configHash = await (async () => {
+    const configFilePath = await prettier.resolveConfigFile(pathJoin(getNodeModulesBinDirPath(), '..'));
+
+    if (configFilePath === null) {
+      return '';
+    }
+
+    const data = await fsPr.readFile(configFilePath);
+
+    return crypto.createHash('sha256').update(data).digest('hex');
+  })();
+
+  const prettierAndConfig: PrettierAndConfigHash = {
+    prettier,
+    configHash,
+  };
+
+  getPrettier.cache = prettierAndConfig;
+
+  return prettierAndConfig;
+}
+
+export async function runPrettier(params: { sourceCode: string; filePath: string }): Promise<string> {
+  const { sourceCode, filePath } = params;
+
+  let formattedSourceCode: string;
+
+  try {
+    const { prettier } = await getPrettier();
+
+    const { ignored, inferredParser } = await prettier.getFileInfo(filePath, {
+      resolveConfig: true,
+    });
+
+    if (ignored) {
+      return sourceCode;
+    }
+
+    const config = await prettier.resolveConfig(filePath);
+
+    formattedSourceCode = await prettier.format(sourceCode, {
+      ...config,
+      filePath,
+      parser: inferredParser ?? undefined,
+    });
+  } catch (error) {
+    console.log(chalk.red(`You probably need to upgrade the version of prettier in your project`));
+
+    throw error;
+  }
+
+  return formattedSourceCode;
+}

package/src/bin/tools/transformCodebase.ts

@@ -0,0 +1,81 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { rmSync } from '../tools/fs.rmSync';
+import { crawl } from './crawl';
+
+type TransformSourceCode = (params: { sourceCode: Buffer; filePath: string; fileRelativePath: string }) =>
+  | {
+      modifiedSourceCode: Buffer;
+      newFileName?: string;
+    }
+  | undefined;
+
+/**
+ * Apply a transformation function to every file of directory
+ * If source and destination are the same this function can be used to apply the transformation in place
+ * like filtering out some files or modifying them.
+ * */
+export function transformCodebase(params: {
+  srcDirPath: string;
+  destDirPath: string;
+  transformSourceCode?: TransformSourceCode;
+}) {
+  const { srcDirPath, transformSourceCode } = params;
+
+  const isTargetSameAsSource = path.relative(srcDirPath, params.destDirPath) === '';
+
+  const destDirPath = isTargetSameAsSource
+    ? path.join(srcDirPath, '..', 'tmp_xOsPdkPsTdzPs34sOkHs')
+    : params.destDirPath;
+
+  fs.mkdirSync(destDirPath, {
+    recursive: true,
+  });
+
+  for (const fileRelativePath of crawl({
+    dirPath: srcDirPath,
+    returnedPathsType: 'relative to dirPath',
+  })) {
+    const filePath = path.join(srcDirPath, fileRelativePath);
+    const destFilePath = path.join(destDirPath, fileRelativePath);
+
+    // NOTE: Optimization, if we don't need to transform the file, just copy
+    // it using the lower level implementation.
+    if (transformSourceCode === undefined) {
+      fs.mkdirSync(path.dirname(destFilePath), {
+        recursive: true,
+      });
+
+      fs.copyFileSync(filePath, destFilePath);
+
+      continue;
+    }
+
+    const transformSourceCodeResult = transformSourceCode({
+      sourceCode: fs.readFileSync(filePath),
+      filePath,
+      fileRelativePath,
+    });
+
+    if (transformSourceCodeResult === undefined) {
+      continue;
+    }
+
+    fs.mkdirSync(path.dirname(destFilePath), {
+      recursive: true,
+    });
+
+    const { newFileName, modifiedSourceCode } = transformSourceCodeResult;
+
+    fs.writeFileSync(
+      path.join(path.dirname(destFilePath), newFileName ?? path.basename(destFilePath)),
+      modifiedSourceCode,
+    );
+  }
+
+  if (isTargetSameAsSource) {
+    rmSync(srcDirPath, { recursive: true });
+
+    fs.renameSync(destDirPath, srcDirPath);
+  }
+}

package/src/bin/tools/transformCodebase_async.ts

@@ -0,0 +1,82 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { rmSync } from '../tools/fs.rmSync';
+import { crawl } from './crawl';
+
+type TransformSourceCode = (params: { sourceCode: Buffer; filePath: string; fileRelativePath: string }) => Promise<
+  | {
+      modifiedSourceCode: Buffer;
+      newFileName?: string;
+    }
+  | undefined
+>;
+
+/**
+ * Apply a transformation function to every file of directory
+ * If source and destination are the same this function can be used to apply the transformation in place
+ * like filtering out some files or modifying them.
+ * */
+export async function transformCodebase(params: {
+  srcDirPath: string;
+  destDirPath: string;
+  transformSourceCode?: TransformSourceCode;
+}) {
+  const { srcDirPath, transformSourceCode } = params;
+
+  const isTargetSameAsSource = path.relative(srcDirPath, params.destDirPath) === '';
+
+  const destDirPath = isTargetSameAsSource
+    ? path.join(srcDirPath, '..', 'tmp_xOsPdkPsTdzPs34sOkHs')
+    : params.destDirPath;
+
+  fs.mkdirSync(destDirPath, {
+    recursive: true,
+  });
+
+  for (const fileRelativePath of crawl({
+    dirPath: srcDirPath,
+    returnedPathsType: 'relative to dirPath',
+  })) {
+    const filePath = path.join(srcDirPath, fileRelativePath);
+    const destFilePath = path.join(destDirPath, fileRelativePath);
+
+    // NOTE: Optimization, if we don't need to transform the file, just copy
+    // it using the lower level implementation.
+    if (transformSourceCode === undefined) {
+      fs.mkdirSync(path.dirname(destFilePath), {
+        recursive: true,
+      });
+
+      fs.copyFileSync(filePath, destFilePath);
+
+      continue;
+    }
+
+    const transformSourceCodeResult = await transformSourceCode({
+      sourceCode: fs.readFileSync(filePath),
+      filePath,
+      fileRelativePath,
+    });
+
+    if (transformSourceCodeResult === undefined) {
+      continue;
+    }
+
+    fs.mkdirSync(path.dirname(destFilePath), {
+      recursive: true,
+    });
+
+    const { newFileName, modifiedSourceCode } = transformSourceCodeResult;
+
+    fs.writeFileSync(
+      path.join(path.dirname(destFilePath), newFileName ?? path.basename(destFilePath)),
+      modifiedSourceCode,
+    );
+  }
+
+  if (isTargetSameAsSource) {
+    rmSync(srcDirPath, { recursive: true });
+
+    fs.renameSync(destDirPath, srcDirPath);
+  }
+}

package/src/bin/tsconfig.json

@@ -0,0 +1,23 @@
+{
+  "compilerOptions": {
+    "sourceMap": false,
+    "newLine": "LF",
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "strict": true,
+    "downlevelIteration": true,
+    "noFallthroughCasesInSwitch": true,
+    "composite": true,
+    "rootDir": ".",
+    "module": "ES2020",
+    "target": "ES2017",
+    "esModuleInterop": true,
+    "lib": ["es2015", "ES2019.Object"],
+    "moduleResolution": "node"
+  },
+  "include": ["**/*.ts"],
+  "exclude": ["initialize-account-theme/boilerplate"],
+  "ts-node": {
+    "esm": true
+  }
+}