pages_core 3.14.0 → 3.15.0

data/app/javascript/lib/Tree.ts

@@ -50,42 +50,27 @@
   SOFTWARE.
  */
 
-export type TreeId = number | string;
-type MovePlacement = "before" | "after" | "prepend" | "append";
-
-export interface TreeNode {
-  children: TreeNode[];
-  collapsed: boolean;
-}
+import * as Trees from "../types/Trees";
 
-export interface TreeIndex<T extends TreeNode = TreeNode> {
-  id: number;
-  node: T;
-  children: TreeIndex<T>[];
-  parent: TreeIndex<T>;
-  next: TreeIndex<T> | null;
-  prev: TreeIndex<T> | null;
-  top: number;
-  height: number;
-}
+type MovePlacement = "before" | "after" | "prepend" | "append";
 
-function indexName(id: number | string): string {
+function indexName(id: Trees.Id): string {
   return `${id}`;
 }
 
-export default class Tree<N extends TreeNode = TreeNode> {
+export default class Tree<N extends Trees.Node = Trees.Node> {
   cnt: number;
   obj: N;
-  indexes: Record<string, TreeIndex<N>>;
+  indexes: Record<string, Trees.Index<N>>;
 
   constructor(obj: N) {
     this.cnt = 1;
-    this.obj = obj || { children: [] };
+    this.obj = obj || ({ children: [] } as N);
     this.indexes = {};
     this.build(this.obj);
   }
 
-  build(obj: N): TreeIndex<N> {
+  build(obj: N): Trees.Index<N> {
     const indexes = this.indexes;
     const startId = this.cnt;
 
@@ -93,12 +78,13 @@ export default class Tree<N extends TreeNode = TreeNode> {
     indexes[indexName(this.cnt)] = index;
     this.cnt++;
 
-    const walk = (objs: TreeIndex<N>[], parent: TreeIndex<N>) => {
-      const children: TreeIndex<N>[] = [];
-      objs.forEach((obj) => {
-        const index: TreeIndex<N> = {};
-        index.id = this.cnt;
-        index.node = obj;
+    const walk = (objs: Trees.Node[], parent: Trees.Index<N>) => {
+      const children: Trees.Id[] = [];
+      objs.forEach((obj: N) => {
+        const index: Trees.Index<N> = {
+          id: this.cnt,
+          node: obj
+        };
 
         if (parent) {
           index.parent = parent.id;
@@ -132,12 +118,12 @@ export default class Tree<N extends TreeNode = TreeNode> {
     return index;
   }
 
-  getIndex(id: TreeId): TreeIndex<N> {
+  getIndex(id: Trees.Id) {
     return this.indexes[indexName(id)];
   }
 
-  removeIndex(index: TreeIndex<N>) {
-    const del = (index: TreeIndex<N>) => {
+  removeIndex(index: Trees.Index<N>) {
+    const del = (index: Trees.Index<N>) => {
       delete this.indexes[indexName(index.id)];
       if (index.children && index.children.length) {
         index.children.forEach((child) => {
@@ -148,11 +134,11 @@ export default class Tree<N extends TreeNode = TreeNode> {
     del(index);
   }
 
-  get(id: TreeId): N {
+  get(id: Trees.Id) {
     return this.getIndex(id).node;
   }
 
-  remove(id: TreeId): N {
+  remove(id: Trees.Id) {
     const index = this.getIndex(id);
     const node = this.get(id);
 
@@ -168,7 +154,7 @@ export default class Tree<N extends TreeNode = TreeNode> {
     return node;
   }
 
-  updateChildren(children: TreeIndex<N>[]) {
+  updateChildren(children: Trees.Id[]) {
     children.forEach((id, i) => {
       const index = this.getIndex(id);
       index.prev = index.next = null;
@@ -181,7 +167,7 @@ export default class Tree<N extends TreeNode = TreeNode> {
     });
   }
 
-  insert(obj: N, parentId: TreeId, i: number): TreeIndex<N> {
+  insert(obj: N, parentId: Trees.Id, i: number) {
     const parentIndex = this.getIndex(parentId);
     const parentNode = this.get(parentId);
 
@@ -202,25 +188,25 @@ export default class Tree<N extends TreeNode = TreeNode> {
     return index;
   }
 
-  insertBefore(obj: N, destId: TreeId): TreeIndex<N> {
+  insertBefore(obj: N, destId: Trees.Id) {
     const destIndex = this.getIndex(destId);
     const parentId = destIndex.parent;
     const i = this.getIndex(parentId).children.indexOf(destId);
     return this.insert(obj, parentId, i);
   }
 
-  insertAfter(obj: N, destId: TreeId): TreeIndex<N> {
+  insertAfter(obj: N, destId: Trees.Id) {
     const destIndex = this.getIndex(destId);
     const parentId = destIndex.parent;
     const i = this.getIndex(parentId).children.indexOf(destId);
     return this.insert(obj, parentId, i + 1);
   }
 
-  prepend(obj: N, destId: TreeId): TreeIndex<N> {
+  prepend(obj: N, destId: Trees.Id) {
     return this.insert(obj, destId, 0);
   }
 
-  append(obj: N, destId: TreeId): TreeIndex<N> {
+  append(obj: N, destId: Trees.Id) {
     const destIndex = this.getIndex(destId);
     destIndex.children = destIndex.children || [];
     return this.insert(obj, destId, destIndex.children.length);
@@ -237,13 +223,13 @@ export default class Tree<N extends TreeNode = TreeNode> {
     root.left = left++;
 
     const walk = (
-      children: TreeIndex<N>[],
-      parent: TreeIndex<N>,
+      children: Trees.Id[],
+      parent: Trees.Index<N>,
       left: number,
       collapsed: boolean
     ) => {
       let height = 1;
-      children.forEach((id: TreeId) => {
+      children.forEach((id: Trees.Id) => {
         const node = this.getIndex(id);
         if (collapsed) {
           node.top = null;
@@ -276,13 +262,13 @@ export default class Tree<N extends TreeNode = TreeNode> {
     }
   }
 
-  move(fromId: TreeId, toId: TreeId, placement: MovePlacement): TreeIndex<N> {
+  move(fromId: Trees.Id, toId: Trees.Id, placement: MovePlacement) {
     if (fromId === toId || toId === 1) {
       return;
     }
 
     const obj = this.remove(fromId);
-    let index: TreeIndex<N>;
+    let index: Trees.Index<N>;
 
     if (placement === "before") {
       index = this.insertBefore(obj, toId);
@@ -306,7 +292,7 @@ export default class Tree<N extends TreeNode = TreeNode> {
     }
   }
 
-  getNodeByTop(top) {
+  getNodeByTop(top: Trees.Id) {
     const indexes = this.indexes;
     for (const id in indexes) {
       if (Object.prototype.hasOwnProperty.call(indexes, id)) {

data/app/javascript/lib/request.ts

@@ -19,24 +19,24 @@ function jsonFetchOptions() {
 }
 
 export async function postJson(url: string, data: Record<string, unknown>) {
-  const options = { ...jsonFetchOptions(), method: "POST" };
-  if (data) {
-    options.body = JSON.stringify(data);
-  }
-  const response = await fetch(url, options);
+  const response = await fetch(url, {
+    ...jsonFetchOptions(),
+    method: "POST",
+    body: data ? JSON.stringify(data) : null
+  });
   return response.json();
 }
 
 export async function putJson(url: string, data: Record<string, unknown>) {
-  const options = { ...jsonFetchOptions(), method: "PUT" };
-  if (data) {
-    options.body = JSON.stringify(data);
-  }
-  const response = await fetch(url, options);
+  const response = await fetch(url, {
+    ...jsonFetchOptions(),
+    method: "PUT",
+    body: data ? JSON.stringify(data) : null
+  });
   return response.json();
 }
 
-export async function post(url: string, data: Record<string, unknown>) {
+export async function post(url: string, data: FormData) {
   const response = await fetch(url, {
     method: "POST",
     body: data,

data/app/javascript/stores/useToastStore.ts

@@ -1,6 +1,6 @@
 import { create } from "zustand";
 
-export interface Toast {
+interface Toast {
   type: string;
   message: string;
 }

data/app/javascript/types/Attachments.ts

@@ -0,0 +1,29 @@
+import * as Drag from "./Drag";
+import { Locale, LocalizedValue } from "../types";
+
+export interface Resource {
+  id: number | null;
+  name: LocalizedValue;
+  description: LocalizedValue;
+  url: string;
+  filename: string;
+}
+
+export interface Record extends Drag.DraggableRecord {
+  id?: number;
+  attachment: Resource;
+  uploading?: boolean;
+}
+
+export interface Options {
+  attribute: string;
+  locale: string;
+  locales: { [index: string]: Locale };
+  showEmbed: boolean;
+}
+
+export interface State {
+  collection: Drag.Collection<Record>;
+  deleted: Record[];
+  setDeleted: (records: Record[]) => void;
+}

data/app/javascript/types/Crop.ts

@@ -0,0 +1,36 @@
+import * as Images from "./Images";
+
+export interface Position {
+  x: number;
+  y: number;
+}
+
+export interface Size {
+  width: number;
+  height: number;
+}
+
+export interface Params {
+  crop_start_x: number;
+  crop_start_y: number;
+  crop_width: number;
+  crop_height: number;
+  crop_gravity_x: number;
+  crop_gravity_y: number;
+}
+
+export interface State extends Params {
+  aspect: number | null;
+  cropping: boolean;
+  image: Images.Resource;
+}
+
+export interface CropSize extends Position, Size {
+  aspect?: number;
+}
+
+export type Action =
+  | { type: "completeCrop" | "startCrop" | "toggleFocal" }
+  | { type: "setCrop"; payload: CropSize }
+  | { type: "setAspect"; payload: number }
+  | { type: "setFocal"; payload: Position };

data/app/javascript/types/Drag.ts

@@ -0,0 +1,34 @@
+export type DraggableRecord = Record<string, unknown>;
+
+export interface Draggable<T = DraggableRecord> {
+  record: T;
+  ref: React.MutableRefObject<HTMLDivElement>;
+  rect: DOMRect | null;
+  handle: string;
+}
+
+export type Item<T = DraggableRecord> = Draggable<T> | "Files";
+
+export type CollectionAction<T = DraggableRecord> =
+  | {
+      type: "append" | "prepend" | "insertFiles" | "replace" | "reorder";
+      payload: Item<T>[];
+    }
+  | { type: "update"; payload: Item<T> }
+  | { type: "remove"; payload: Draggable<T> }
+  | { type: "updatePositions"; payload?: Draggable<T> };
+
+export interface Collection<T = DraggableRecord> {
+  ref: React.MutableRefObject<HTMLDivElement>;
+  draggables: Item<T>[];
+  dispatch: (CollectionAction) => void;
+}
+
+export interface Position {
+  x: number | null;
+  y: number | null;
+}
+
+export interface State<T = DraggableRecord> extends Position {
+  dragging: Item<T> | false;
+}

data/app/javascript/types/Images.ts

@@ -0,0 +1,47 @@
+import * as Drag from "./Drag";
+import { Locale, LocalizedValue } from "../types";
+
+export interface Resource {
+  id: number | null;
+  alternative: LocalizedValue;
+  caption: LocalizedValue;
+  content_type: string;
+  filename: string;
+  crop_start_x: number | null;
+  crop_start_y: number | null;
+  crop_width: number | null;
+  crop_height: number | null;
+  crop_gravity_x: number;
+  crop_gravity_y: number;
+  real_width: number;
+  real_height: number;
+  original_url: string;
+  thumbnail_url: string;
+  uncropped_url: string;
+}
+
+export interface Record extends Drag.DraggableRecord {
+  id?: number;
+  image: Resource;
+  primary?: boolean;
+  src?: string;
+  file?: File;
+}
+
+export type Response = Resource | { status: "error"; error: string };
+
+export interface GridOptions {
+  attribute: string;
+  enablePrimary: boolean;
+  locale: string;
+  locales: { [index: string]: Locale };
+  primaryAttribute: string;
+  showEmbed: boolean;
+}
+
+export interface GridState {
+  primary: Drag.Collection<Record>;
+  images: Drag.Collection<Record>;
+  deleted: Record[];
+  setDeleted: (records: Record[]) => void;
+}

data/app/javascript/types/PageEditor.ts

@@ -0,0 +1,26 @@
+import * as Pages from "./Pages";
+import * as Template from "./Template";
+import { Locale } from "../types";
+
+export type Action =
+  | { type: "setPage"; payload: Pages.SerializedResource }
+  | { type: "setDatesEnabled"; payload: boolean }
+  | { type: "setLocale"; payload: string }
+  | { type: "update"; payload: Partial<Pages.Resource> }
+  | { type: "updateBlocks"; payload: Partial<Pages.Blocks> };
+
+export interface State<T = Pages.Resource> {
+  locale: string;
+  locales: { [index: string]: Locale };
+  page: T;
+  templates: Template.Config[];
+  datesEnabled?: boolean;
+  inputDir?: "ltr" | "rtl";
+  templateConfig?: Template.Config;
+}
+
+export interface Tab {
+  id: string;
+  name: string;
+  enabled: boolean;
+}

data/app/javascript/types/Pages.ts

@@ -0,0 +1,75 @@
+import * as Attachments from "./Attachments";
+import * as Images from "./Images";
+import * as Trees from "./Trees";
+import { LocalizedValue, MaybeLocalizedValue } from "../types";
+
+export type Author = [name: string, id: number];
+
+export interface Ancestor {
+  id: number;
+  name: LocalizedValue;
+  path_segment: LocalizedValue;
+}
+
+export interface StatusLabels {
+  [index: number]: string;
+}
+
+export interface TreeResource {
+  id?: number;
+  blocks: Blocks;
+  news_page: boolean;
+  parent_page_id: number;
+  permissions: string[];
+  pinned: boolean;
+  published_at: Date;
+  status: number;
+}
+
+export interface Blocks {
+  [index: string]: MaybeLocalizedValue;
+  name: LocalizedValue;
+}
+
+export interface MetaImage {
+  src?: string;
+  image?: Images.Resource;
+}
+
+export interface Resource extends TreeResource {
+  all_day: boolean;
+  ancestors: Ancestor[];
+  blocks: Blocks;
+  enabled_tags: string[];
+  ends_at: Date;
+  errors: { attribute: string; message: string }[];
+  feed_enabled: boolean;
+  meta_image: MetaImage;
+  page_files: Attachments.Record[];
+  page_images: Images.Record[];
+  path_segment: MaybeLocalizedValue;
+  redirect_to: string;
+  starts_at: Date;
+  tags_and_suggestions: string[];
+  template: string;
+  unique_name: string;
+  urls: LocalizedValue;
+  user_id: number;
+}
+
+export interface SerializedResource
+  extends Omit<Resource, "published_at" | "starts_at" | "ends_at"> {
+  published_at: string;
+  starts_at: string;
+  ends_at: string;
+}
+
+export interface TreeItem extends Partial<TreeResource> {
+  blocks: Blocks;
+  editing?: boolean;
+  permissions?: string[];
+}
+
+export interface TreeNode extends TreeItem, Trees.Node {
+  children: TreeNode[];
+}

data/app/javascript/types/Tags.ts

@@ -0,0 +1,9 @@
+export interface Action {
+  type: "addTag" | "toggleTag";
+  payload: string;
+}
+
+export interface State {
+  enabled: string[];
+  tags: string[];
+}

data/app/javascript/types/Template.ts

@@ -0,0 +1,24 @@
+export interface Block {
+  name: string;
+  title: string;
+  description?: string;
+  optional: boolean;
+  enforced: boolean;
+  size: string;
+  class?: string;
+  localized?: boolean;
+  placeholder?: string;
+  options?: [string, string][];
+  type?: string;
+}
+
+export interface Config {
+  name: string;
+  template_name: string;
+  blocks: Block[];
+  metadata_blocks: Block[];
+  images: boolean;
+  dates: boolean;
+  tags: boolean;
+  files: boolean;
+}

data/app/javascript/types/Trees.ts

@@ -0,0 +1,19 @@
+export type Id = number | string;
+
+export interface Node {
+  children: Array<Node>;
+  collapsed: boolean;
+  root?: boolean;
+}
+
+export interface Index<T extends Node = Node> {
+  id: number;
+  node: T;
+  children?: Id[];
+  parent?: Id;
+  top?: number;
+  height?: number;
+  next?: Id;
+  prev?: Id;
+  left?: number;
+}

data/app/javascript/types.ts

@@ -3,28 +3,5 @@ export interface Locale {
   dir: "ltr" | "rtl";
 }
 
-export interface AttachmentResource {
-  id: number | null;
-  name: Record<string, string>;
-  description: Record<string, string>;
-  url: string;
-}
-
-export interface ImageResource {
-  id: number | null;
-  alternative: Record<string, string>;
-  caption: Record<string, string>;
-  content_type: string;
-  filename: string;
-  crop_start_x: number | null;
-  crop_start_y: number | null;
-  crop_width: number | null;
-  crop_height: number | null;
-  crop_gravity_x: number;
-  crop_gravity_y: number;
-  real_width: number;
-  real_height: number;
-  original_url: string;
-  thumbnail_url: string;
-  uncropped_url: string;
-}
+export type LocalizedValue = Record<string, string>;
+export type MaybeLocalizedValue = LocalizedValue | string;

data/app/models/attachment.rb

@@ -61,7 +61,7 @@ class Attachment < ApplicationRecord
   end
 
   def filename_extension?
-    filename =~ /\./
+    filename.include?(".")
   end
 
   # Includes a timestamp fingerprint in the URL param, so

data/app/models/concerns/pages_core/authenticable_user.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module PagesCore
+  module AuthenticableUser
+    extend ActiveSupport::Concern
+
+    included do
+      has_secure_password
+
+      validates(:otp_secret, presence: true, if: :otp_enabled?)
+      validates(
+        :password,
+        length: {
+          minimum: 8,
+          maximum: ActiveModel::SecurePassword::MAX_PASSWORD_LENGTH_ALLOWED,
+          allow_blank: true
+        }
+      )
+
+      after_initialize { |u| u.session_token ||= u.class.random_session_token }
+      before_validation :update_session_token
+    end
+
+    module ClassMethods
+      def authenticate(email, password:)
+        User.find_by(email:).try(:authenticate, password)
+      end
+
+      def random_session_token
+        SecureRandom.hex(32)
+      end
+    end
+
+    def can_login?
+      activated?
+    end
+
+    def recovery_codes=(codes)
+      self.hashed_recovery_codes = codes.map do |c|
+        BCrypt::Password.create(c, cost: 8)
+      end
+    end
+
+    def use_recovery_code!(code)
+      valid_hashes = hashed_recovery_codes.select do |c|
+        BCrypt::Password.new(c) == code
+      end
+      return false unless valid_hashes.any?
+
+      update(hashed_recovery_codes: hashed_recovery_codes - valid_hashes)
+      true
+    end
+
+    private
+
+    def update_session_token
+      return unless password_digest_changed? ||
+                    otp_enabled_changed?
+
+      self.session_token = self.class.random_session_token
+    end
+  end
+end

data/app/models/concerns/pages_core/emailable.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module PagesCore
+  module Emailable
+    extend ActiveSupport::Concern
+
+    included do
+      validates :email,
+                presence: true,
+                format: { with: /\A([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})\Z/i },
+                uniqueness: { case_sensitive: false }
+
+      normalizes :email, with: ->(email) { email.strip }
+    end
+  end
+end